In dieser Beitragsreihe zeige ich dir, wie ich pstack verwende, meine persönliche Sammlung von Skills für anspruchsvolle Ingenieursarbeit. Damit konnte ich monatlich 2.000 PRs mit hohem Vertrauen in die Produktion ausliefern.
Persönlich habe ich nie großen Wert darauf gelegt, wie viele Codezeilen oder PRs ich abgeliefert habe. Vor Agenten hat das niemanden interessiert, und das zu Recht, denn rohe Produktivität war nicht immer gleichbedeutend mit Qualität oder einem sichtbaren Ergebnis für die Nutzer. Es war einfach eine Eitelkeitsmetrik.
Aber ich habe beim Aufbau von pstack festgestellt, dass die Menge doch eine Rolle spielt, besonders wenn man das Qualitätsniveau des Produkts mit Agenten halten oder sogar steigern kann. Zum Beispiel habe ich vor etwa 2 Monaten mit der Arbeit an Grok @Bot begonnen, als es noch in den Kinderschuhen steckte und die Codebasis frisch war, aber zu wachsen begann. Obwohl das Team wächst und jetzt täglich hunderte PRs in die Grok @Bot-Codebasis einfließen, hat mir pstack ermöglicht, die Codequalität für alle hoch zu halten, indem ich ständig Code überwache, refaktoriere, neue Lints und Checks hinzufüge und auch an Funktionen arbeite.
https://x.com/poteto/status/2090546476464451907
https://x.com/poteto/status/2078527882499150286
Der Gärtner und Betreuer von Grok @Bot zu sein, war mir nur durch pstack möglich. Unser früher Schwung nach dem Bau des Prototyps war sehr hoch und viele Leute kamen zum Team. Ich hatte einen kritischen Moment der Gelegenheit, die gesamte Codebasis zu refaktorieren, während sie gebaut und erweitert wurde und ohne Ausfallzeiten, in etwas mit starken Fundamenten. Eine Codebasis mit hoher Qualität, die skaliert, egal wie viele Ingenieure (und vor allem Nicht-Ingenieure) dazu beitragen. All diese Arbeit erfordert, dass ich die Grundlagen von Grok Bot refaktoriere und verbessere, während es gebaut wird, und das kann man nur tun, wenn die Grundlagen mit der Anzahl der Beiträge Schritt halten können.
Grok Bot ist eine der effizientesten und leistungsfähigsten KI-Desktop-Apps auf dem Markt
Der Beweis liegt in Grok @Bot selbst. In den nächsten Wochen werde ich dir alles erzählen, was du wissen musst, um eine qualitativ hochwertige App mit pstack zu bauen und zu warten.
Teil 1 – Verifikation ist alles, was du brauchst
Die wichtigste Fähigkeit, die du in deinem Werkzeugkasten haben solltest, ist eine hochwertige Verifikationsfähigkeit. Diese Fähigkeit ist so wichtig zu haben und zu pflegen, dass ich sie eher als kritische Infrastruktur betrachte, denn als "nur" eine Fähigkeit. Eine gute wird die Leistung deines gesamten Teams, einschließlich Nicht-Ingenieuren, vervielfachen. Gut gemacht, wirst du die Leistung deines gesamten Teams um das 100- bis 1000-fache steigern.
Falls du mit dem Begriff nicht vertraut bist: Verifikation bedeutet, dass ein Agent seine eigene Arbeit überprüfen kann. Er kann so lange weitermachen, bis er seine Aufgabe erfolgreich erledigt hat, weil er jetzt den Kreislauf schließen kann, ohne dass du der Engpass bist. Wenn du mehr über die Geschichte erfahren möchtest, wie ich meinen ersten Verifikations-Skill für Cursor erstellt habe, wirf einen Blick auf meinen vorherigen Beitrag Loops You Can Trust.
Lasst uns gemeinsam einen Verifikations-Skill bauen
Installiere zunächst pstack und führe dann /create-verification-skill aus. Ich empfehle auch, Dr Eggbot, meinen Bot, der dir hilft, hochwertige Bots zu erstellen, zu deinem Team hinzuzufügen. Dr Eggbot wird mit pstack ausgeliefert. Er bringt Code-Bots bei, wie man ihn verwendet, und kann auch Nicht-Code-Bots mit der gleichen Strenge erstellen.
Du kannst Dr Eggbot bitten, einen Ingenieur-Bot für dich zu erstellen, den du dann bitten kannst, /create-verification-skill auszuführen und eine tägliche Routine einzurichten, um /maintain-verification-skill auszuführen.
Ich liebe Dr Eggbot
Während das läuft, lass uns durchgehen, was der Skill tut und wie er einen hochwertigen Verifikations-Skill für dich erstellt.
Ich habe alle unsere Verifikations-Skills, die wir zum Bau von Grok @Bot und Cursor verwenden, in diesen Skill als eine Art Meta-Skill destilliert. Er bringt deinem Agenten bei, wie man einen hochwertigen für deine eigene App erstellt.
Hier ist die Wahl des Tech-Stacks wichtig. Wenn du zum Beispiel eine App in Electron oder für das Web baust, kannst du die umfangreichen Debugging-Tools des JS-Ökosystems nutzen. Zum Beispiel erlaubt dir das Chrome DevTools Protocol (CDP), dieselben Werkzeuge zu verwenden, die in den Entwicklertools deines Browsers verfügbar sind. Oder wenn du eine iOS-App baust, nutze den Simulator.
Idealerweise möchtest du die Möglichkeit haben, mit deiner App zu interagieren, sie zu debuggen, Perf-Traces zu erstellen und alle anderen Debugging- und Entwicklungswerkzeuge zu nutzen, die du normalerweise verwenden würdest, wenn du die App von Hand entwickeln würdest. Wenn du keine umfangreiche Laufzeitumgebung zur Verfügung hast, musst du deinen Agenten möglicherweise bitten, Werkzeuge für dich zu erstellen (z. B. mit lldb oder einem benutzerdefinierten Paket, das in Dev-Umgebungen als Sidecar läuft), oder einfach das nutzen, was verfügbar ist.
Ich persönlich bin der Meinung, dass agentische Verifikation so wichtig ist, dass ich unironisch vorschlagen würde, deine eigenen umfangreichen Debugging-Tools zu bauen oder sogar einen anderen Tech-Stack zu wählen, um unfaire Vorteile und extreme Produktivität bei der Softwareentwicklung zu haben. Wie ich bereits erwähnt habe, ermöglicht es Agenten, ihre eigene Arbeit zu verifizieren, jedem in deiner Organisation, Beiträge zu leisten und zu validieren, dass ihre Änderungen tatsächlich funktionieren. Je schwieriger dein Tech-Stack zu debuggen und zu kontrollieren ist, desto schwieriger wird es sein, Agenten produktiv einzusetzen.
Mach es reproduzierbar
In pstack haben wir ein Prinzip namens "Build the Lever". Im Kontext der Erstellung eines Skills bedeutet das, dass wir Agenten lieber Werkzeuge als nur Markdown geben. Für Verifikations-Skills bedeutet dies, ein kleines CLI zu erstellen, das die Interaktion und das Debugging deiner App in einem kleinen, agentenfreundlichen Dienstprogramm skriptet. Das bedeutet, dass Agenten weniger Token verbrauchen, um eine Aufgabe zu erledigen (ein CLI-Kommando ausführen, anstatt ein Wegwerf-Skript zu schreiben, um auf etwas zu klicken), und macht deinen Verifikations-Skill reproduzierbarer und testbarer.
Hier ist ein hypothetisches Beispiel eines CLIs, das dein Agent für eine Electron-App erstellen könnte:
1# health2node .cursor/skills/verify-atlas/control-atlas.mjs doctor34# open a blank thread and send5node .cursor/skills/verify-atlas/control-atlas.mjs new-session6node .cursor/skills/verify-atlas/control-atlas.mjs send "list open tasks in this project"78# keyboard path9node .cursor/skills/verify-atlas/control-atlas.mjs press "Meta+KeyN"1011# accessibility snapshot of the live UI12node .cursor/skills/verify-atlas/control-atlas.mjs snapshot1314# screenshot for evidence15node .cursor/skills/verify-atlas/control-atlas.mjs screenshot /tmp/atlas-proof.png1617# wait for streaming / layout to settle18node .cursor/skills/verify-atlas/control-atlas.mjs wait-settle1920# flip a feature flag for the session21node .cursor/skills/verify-atlas/control-atlas.mjs feature-flag rooms_v2 on
Jetzt können alle Agenten dieses CLI verwenden, um schnell durch deine App zu navigieren und sie zu debuggen. Du solltest auch anfangen, über die Entwicklererfahrung beim Bau deiner App nachzudenken:
- Seeding einer Entwicklerdatenbank
- Umgang mit Authentifizierung, Testbenutzern, API-Aufrufen gegen eine Test-/Staging-Umgebung
- Installieren und Hochfahren deiner Entwicklungsumgebung auf konsistente Weise
All das sind Dinge, über die du wahrscheinlich sowieso nachdenken musstest, als du selbst Code geschrieben hast. Betrachte es also als das Hauptwerkzeug deiner Agenten für die Entwicklungsarbeit an deiner App. Halte es gut gewartet und getestet!
Einige weitere Beispielbefehle, die du in Betracht ziehen könntest:
1- **Inspektion:** `info`, `snapshot`, `screenshot`, `components`2- **Navigation:** `home`, `new-session`, `select-project`, `select-runtime`, `scroll`3- **Interaktion:** `send`, `click`, `click-xy`, `aria-click`, `type`, `press`, `eval`, `upload-image`, `add-context`, `feature-flag`4- **Leistung:** `trace`, `profile`, `record`, `perf-metrics`, `wait-settle`5- **Streaming:** `console`, `network-log`, `network-summary`6- **Gesundheit & Bereinigung:** `doctor`, `cleanup`, `watch --restart`
Sobald du dieses grundlegende Setup hast, solltest du bereits eine große Verbesserung bei deinen Agenten feststellen. Sie sollten in der Lage sein, sich problemlos in deiner App zurechtzufinden und sie zu debuggen.
Ich empfehle, hier Zeit zu investieren, um dieses CLI gut und fehlerfrei zu machen, bevor du etwas Fortgeschritteneres tust. Du solltest auch darüber nachdenken (oder deinen Agenten bitten), ein agentenfreundliches CLI zu entwerfen. Es gibt viele Online-Ressourcen, auf die du deinen Agenten verweisen kannst, aber die wichtigsten Eigenschaften, die ich mag, sind:
- Die API ist einfach zu kombinieren – denke an John Ousterhouts Philosophie der tiefen Module
- Jeder Befehl mit potenziell destruktiven Nebenwirkungen sollte eine --dry-run-Option haben
- Verwende Unterbefehle, um Funktionalität schrittweise zu enthüllen, anstatt alles auf einmal
- Fehlermeldungen sollten sehr beschreibend sein und dem Agenten sagen, was er stattdessen tun soll
- Umfangreicher --help-Text
- Ausgaben in maschinenlesbarer Form (z. B. JSON)
Schneller werden mit Parallelisierung durch Cloud Agents anstelle von Worktrees
Wenn du einige Erfolge mit der Ausführung deines Verifikations-Skills hattest, um ein paar PRs zu landen, fragst du dich vielleicht, ob du mehr parallelisieren kannst. Wenn ein Agent zum Beispiel deinen Prompt nehmen und ihn größtenteils in einen mergebaren Zustand bringen kann, macht dich das nicht frei, mehr Agenten laufen zu lassen?
Dein erster Instinkt wird sein, Worktree-Unterstützung hinzuzufügen, was bedeutet, dass deine Agenten git verwenden können, um eine verfolgte Kopie des Repos zu erstellen, in der sie Änderungen isoliert vom Haupt-Checkout vornehmen können. Theoretisch kannst du so mehrere Agenten gleichzeitig laufen lassen, ohne dass sich ihre Änderungen gegenseitig überschreiben.
Ich würde davon abraten. Erstens verbraucht es viel Speicherplatz und Ressourcen auf deinem Rechner. Je nach Größe deines Repos und der Leistungsfähigkeit deines Rechners kannst du mit Worktrees vielleicht bis zu 10 Agenten parallel laufen lassen. Aber es gibt einen weitaus besseren Weg!
Cursors Cloud Agents sind Agenten, die in der Cloud auf der Infrastruktur von Cursor laufen. Diese Agenten haben Zugriff auf einen echten Computer, was bedeutet, dass sie Abhängigkeiten installieren, deine App ausführen, Videos und Screenshots aufnehmen und mit deiner App interagieren können wie ein echter Benutzer. Wenn du im vorherigen Schritt genug investiert hast, um deine Entwicklererfahrung gut zu machen, sollte es kein großer Aufwand sein, Cloud Agents einzurichten. Wenn du deine Cloud-Umgebung zum ersten Mal einrichtest, senden wir einen Agenten, der dir hilft, sie korrekt einzurichten und zum Laufen zu bringen. Nach dem ersten Build erstellen wir einen Snapshot, was bedeutet, dass nachfolgende Cloud-Agent-Läufe immer schnell starten.
Ich empfehle dringend, sich die Zeit zu nehmen, Cloud Agents einzurichten, da dies eine massive Produktivitätssteigerung durch Parallelisierung ermöglicht. In einem späteren Beitrag werde ich dir zeigen, wie ich hunderte von Unteragenten parallel in der Cloud laufen lasse! Aber für jetzt: Richte deine Umgebung ein und bringe sie in einen Zustand, in dem du anfangen kannst, Vertrauen zu haben, alle deine Agenten in der Cloud laufen zu lassen.
Halte Agenten mit Feature Maps schlau
Wenn deine App komplexer wird, brauchen Agenten mehr Anleitung, um Funktionen zu finden und mit ihnen zu interagieren. Dazu habe ich etwas entwickelt, das ich die Feature Map nenne. Wie der Name schon sagt, ist es eine leicht durchsuchbare Karte aller Funktionen, die in deiner App verfügbar sind, was sie tun und wie man aus Benutzersicht dorthin gelangt.
Hier ist ein Beispiel einer Feature Map, die ich für eine fiktive App namens Atlas vorbereitet habe. Es sind nur ein paar Markdown-Dateien, die in der SKILL.md der Verifikation erwähnt werden.
Du kannst diese Datei überall ablegen, aber in /create-verification-skill erstellen wir automatisch ein references/features-Verzeichnis zusammen mit einer README.md. Die Readme ist die Karte selbst: eine allgemeine Übersicht über alle wichtigen verfügbaren Funktionen mit Links zu spezifischen Details. Eine Beispiel-Funktion sieht etwa so aus:
1# Einstellungen23Vollbild-Overlay für Einstellungen und dessen Registerkartenset.45## Unterfunktionen67- settings-overlay: Vollbild-Overlay, geöffnet über das Zahnrad oder Cmd/Ctrl+,8- settings-nav: linke Navigationsleiste mit Registerkarten (Allgemein, Darstellung, Modelle, Plan & Nutzung, ...).9- settings-search: Suche im Overlay (Cmd/Ctrl+K, während die Einstellungen geöffnet sind).10- theme-picker: schnelle Themensteuerung unter Darstellung.1112## Wie man dorthin gelangt (Benutzersicht)1314Klicke auf das Zahnrad neben dem Konto-Avatar oder drücke Cmd/Ctrl+,. Wähle einen Tab aus der linken Navigation. Gib in das Einstellungssuchfeld ein, um zu springen. Escape oder das Schließen-Steuerelement schließt das Overlay.1516## Steuerung mit control-atlas1718bash19node .cursor/skills/verify-atlas/control-atlas.mjs press "Meta+Comma"20node .cursor/skills/verify-atlas/control-atlas.mjs snapshot21node .cursor/skills/verify-atlas/control-atlas.mjs press "Escape"2223- Overlay-Root: Suche im a11y-Baum nach einem Dialog/Bereich namens Einstellungen.24- Tabs: Klicke nach sichtbarem Namen. Plan & Nutzung kann für einige Kontostände fehlen.25- Während die Einstellungen geöffnet sind, ist Cmd/Ctrl+K die Einstellungssuche, nicht die globale Palette (siehe `multi-surface-journeys.md`).2627## Fallstricke2829- Das Schließen der Einstellungen mitten in einer Suite kann den Fokus an einer nutzlosen Stelle hinterlassen. `new-session` oder `home` stellt ihn wieder her.30- Einige Tabs sind berechtigungsgesteuert. Überspringe sie mit einem expliziten Kontogrund.
Mach dir keine Sorgen, diese selbst zu schreiben! Wenn du /create-verification-skill ausführst, wird dein Agent automatisch durch deine App gehen, alles katalogisieren und diese Referenzen für dich erstellen.
Die Feature Map ist, zusammen mit dem CLI, einer der Hauptgründe, warum pstacks Verifikations-Skills so gut sind. Agenten haben jetzt Kontext zu jeder einzelnen Funktion und wissen, wie sie dorthin gelangen, was wertvolle Token in ihrem Kontextfenster spart und ihnen genau beibringt, wofür sie ist und wie sie dorthin kommt.
Du kannst dir die Feature Map als eine Form von "materialisiertem Gedächtnis" vorstellen. Wenn du schon eine Weile mit Agenten arbeitest, kennst du wahrscheinlich das Konzept des Gedächtnisses – typischerweise werden diese als einfache Markdown-Dateien (z. B. ein Obsidian-Vault) oder sogar als etwas Komplexeres wie eine Vektordatenbank gespeichert. Ich persönlich denke, dass deine Codebasis die ultimative Form des Gedächtnisses ist. Code ist eine Projektion der Entscheidungsfindung, die du und dein Team getroffen habt, und repräsentiert die Quelle der Wahrheit dafür, was passiert ist und wie die Dinge tatsächlich funktionieren. Eine Feature Map ist nur eine kompaktere Form davon, die entwickelt wurde, um Token zu sparen. Und da es sich nur um Markdown innerhalb eines Skills handelt, profitiert jeder, der zu deiner Codebasis beiträgt, von diesem gemeinsamen Gedächtnis.
Das bedeutet, dass die Pflege des Verifikations-Skills wirklich wichtig ist. Ich empfehle, /maintain-verification-skill mindestens einmal täglich auszuführen, um sicherzustellen, dass deine Agenten immer die neuesten Details zur Steuerung deiner App haben. Du wirst vielleicht auch feststellen, dass Agenten, je mehr du deinen Verifikations-Skill verwendest, diese automatisch aktualisieren, während sie an deiner App arbeiten. /maintain-verification-skill fängt auf, was übersehen wurde.
So verwendest du deinen Verifikations-Skill
Als Referenz hier ein Beispiel eines Verifikations-Skills, der für eine fiktive App erstellt wurde: https://github.com/poteto/verification-skill-example. Zur Erinnerung: Führe /create-verification-skill aus, um einen zu erstellen, der ein grundlegendes CLI und eine Feature Map enthält.
So verwende ich ihn typischerweise mit pstack.
Zunächst beginne ich natürlich meinen Prompt mit /poteto-mode. Wenn du pstack über Cursor verwendest, kannst du auch Opt + Enter anstelle von nur Enter drücken, wenn du /poteto-mode autovervollständigst – dies fügt den Skill als Custom Mode hinzu, der den Skill anpinnt, sodass dein Agent bei jedem neuen Zug eine Erinnerung erhält, den Skill zu verwenden.
Tippe /poteto-mode und drücke Opt + Enter, um es als Custom Mode anzupinnen
Installiere in Grok @Bot das Plugin und tippe dann /poteto-mode.
Du kannst pstack auch in Grok Bot verwenden!
Beispiel: Neue Funktionen bauen
Zum Bauen neuer Funktionen verwende ich den Verifikations-Skill typischerweise zusammen mit /poteto-mode, um den Agenten zu veranlassen, seine Arbeit zu überprüfen. Zum Beispiel könnte ich so etwas eingeben wie:
/poteto-mode build <Beschreibung der Funktion, nützlicher Kontext>. verwende /control-app, um deine Änderungen zu überprüfen und zeige mir ein Video und Screenshots als Beweis
Wobei /control-app das Ergebnis von /create-verification-skill ist. In Grok @Bot würde ich so etwas eingeben wie:
starte einen Cloud Agent, der /poteto-mode verwendet, um <Beschreibung der Funktion, nützlicher Kontext> zu bauen. verwende /control-app, um deine Änderungen zu überprüfen und zeige mir ein Video und Screenshots als Beweis
Der kleine Unterschied hier ist, dass du in Grok @Bot deinem Bot sagst, er solle einen Cloud Agent starten, anstatt die Arbeit selbst zu erledigen. Der Hauptgrund, warum ich das bevorzuge, ist, dass es deinen Bot freigibt, andere Dinge zu tun, und sein Kontextfenster sauber hält. In diesem Sinne betrachte ich meine Bots eher als Koordinatoren, die Cloud Agents verwalten und überwachen. Cloud Agents bedeuten auch, dass du die gesamte Palette der in Cursor verfügbaren Modelle nutzen kannst, die ihre eigene separate Maschine haben, sodass der Computer deines Bots für andere Dinge frei bleibt.
Beispiel: Leistungsarbeit
starte einen Cloud Agent, der /poteto-mode verwendet, um die anfängliche Ladezeit unserer App zu verbessern. verwende zuerst /control-app, um einen Trace des Status quo zu erstellen und Verbesserungsmöglichkeiten zu identifizieren. führe dann eine gezielte Korrektur durch und verwende /control-app +
/swarm um den Gewinn zu bestätigen
/swarm ist einer der besten Skills, um ihn mit deinem Verifikations-Skill zu kombinieren. Er verteilt eine beliebige Anzahl von Cloud Agents, um deinen Verifikations-Skill auszuführen, sodass du Dinge tun kannst wie einen Leistungsgewinn mit einer ausreichend großen Stichprobe zu bestätigen oder deine App zu fuzzen, um sicherzustellen, dass du nichts kaputt gemacht oder verschlechtert hast.
Beispiel: Benutzerberichte automatisch reproduzieren
Wenn du mit deinem Verifikations-Skill zufrieden bist, kannst du ihn in Grok @Bot-Routinen oder Cursor Automations einbauen. Routinen und Automatisierungen ermöglichen es dir, Dinge nach Zeitplan oder bei einem Ereignis auszuführen.
Wenn du zum Beispiel Benutzerfeedback in Slack einspeist und/oder einen eigenen internen Feedback-Kanal hast, kannst du deine Bots jeden Bericht abhören und automatisch versuchen lassen, ihn mit einem Cloud Agent zu reproduzieren. Wenn dein Verifikations-Skill und deine Feature Map gut genug sind, könntest du sogar beschließen, Probleme ebenfalls automatisch zu beheben.
Es gibt einen Grund, warum ich zuvor sagte, dass Verifikation eine der wichtigsten Fähigkeiten in deinem Werkzeugkasten ist. Sie gibt dir eine Grundlage, um neue Fähigkeiten und Routinen darauf aufzubauen. Und am wichtigsten: Jeder in deinem Team profitiert davon.
Investiere in deinen Verifikations-Skill
Sobald du deinen Verifikations-Skill erstellt hast, halte ihn mit /maintain-verification-skill scharf. Verbessere das CLI weiter und investiere in den Skill, wie du es in kritische Infrastruktur tun würdest. Du könntest sogar eine Bereitschaftsrotation dafür einführen – so wichtig ist es, um die 100- bis 1000-fache Produktivität für dein Team zu erschließen.
Dieser Skill ist die Grundlage für viele andere Skills, die wir im pstack-Leitfaden behandeln werden, und lässt sich wunderbar mit allen kombinieren.
- pstack: https://x.ai/bot/plugin/9717366 (github link
- Dr Eggbot: https://x.ai/bot/93gOz3op1UQdBdbekQFLK
Ich empfehle, Dr Eggbot, meinen Bot, der dir hilft, hochwertige Bots zu erstellen, zu deinem Team hinzuzufügen. Dr Eggbot wird mit pstack ausgeliefert. Er bringt Code-Bots bei, wie man ihn verwendet, und kann auch Nicht-Code-Bots mit der gleichen Strenge erstellen.
Du kannst Dr Eggbot bitten, einen Ingenieur-Bot für dich zu erstellen, den du dann bitten kannst, /create-verification-skill auszuführen und eine tägliche Routine einzurichten, um /maintain-verification-skill auszuführen.
Danke fürs Lesen und bleib dran für Teil 2!
