Loop Engineering
Loop Engineering ist ein neues Konzept, das sich im Juni 2026 schnell in der KI-Programmier-Community verbreitete. Es wurde von Google-Ingenieur Addy Osmani systematisch aufgearbeitet, und der Leiter von Anthropic Claude Code, Boris Cherny, sowie der Entwickler Peter Steinberger vertraten beide öffentlich dieselbe Ansicht.
Dieser Artikel führt Sie von Grund auf dazu, zu verstehen, was Loop Engineering ist, seine wesentlichen Unterschiede zu Prompt Engineering, die sechs Schlüsselelemente, die einen vollständigen Agent Loop ausmachen, und wie Sie Ihren ersten lauffähigen Loop entwerfen.
Die Evolution des AI Engineering
In den vergangenen zwei Jahren hat sich der Fokus der KI-Entwicklung ständig verschoben: von der Erforschung, wie man gute Prompts schreibt, hin zur Organisation von Kontext und Orchestrierung von Tools und Workflows (Harness) und dann zum Aufbau von Loop-Systemen (Loop), die autonom laufen und kontinuierlich Ergebnisse liefern können.
Prompt:怎么问 AI ↓ Context:给 AI 什么信息 ↓ Harness:如何组织 AI 的能力 ↓ Loop:如何让 AI 持续创造结果

| Engineering-Phase | Kernidee | Fokus | Eingabeinhalt | KI-Fähigkeit | Menschliche Rolle | Typisches Szenario |
|---|---|---|---|---|---|---|
| Prompt-Engineering | Bessere Ausgabe durch das Design von Prompts erzielen | Wie man Fragen stellt | Prompt / Anweisung | Single-Turn-Generierung | Fragesteller | Chat, Schreiben, Codegenerierung |
| Context Engineering | Vollständige Hintergrundinformationen organisieren und bereitstellen | Welche Informationen man der KI geben sollte | Wissensdatenbank, Verlaufsdatensätze, Einschränkungen, Kontext | Kontextverständnis | Informationsorganisator | RAG, KI-Suche, Code-Assistent |
| Harness-Engineering (Orchestrierungs-Engineering) | Modelle, Tools und Daten verbinden, um Workflows zu bilden | Wie man Fähigkeiten aufruft | Kontext + API + Toolchain | Aufgaben ausführen | Systemdesigner | Agent, automatisierte Prozesse, Zusammenarbeit mehrerer Tools |
| Loop Engineering | Zielgesteuerte autonome Closed-Loop-Systeme aufbauen | Wie man Ziele kontinuierlich erreicht | Ziele, Zustand, Gedächtnis, Verifikationsmechanismen | Planen → Ausführen → Verifizieren → Beheben → Kontinuierlich laufen | Regelgeber | Claude Code, KI-Programmierung, automatisierte Abläufe, KI-Mitarbeiter |
Die Ursprünge des Loop-Engineerings
Loop-Engineering entstand zu einem klaren Zeitpunkt: im Juni 2026.
Der Wendepunkt: Zwei Sätze, Millionen Shares
Anfang Juni 2026 sagte der Leiter von Anthropic Claude CodeBoris Chernyin einer öffentlichen Rede:
„Ich prompte Claude nicht mehr. Ich habe Loops laufen. Sie sind diejenigen, die Claude prompten und herausfinden, was zu tun ist. Meine Aufgabe ist es, Loops zu schreiben.“
(Ich prompte Claude nicht mehr direkt. Ich habe eine Reihe von Loops laufen, die Claude prompten und entscheiden, was als Nächstes zu tun ist. Meine Aufgabe ist das Schreiben von Loops.)
Ein paar Tage später, am 7. Juni 2026, veröffentlichte der EntwicklerPeter Steinberger– Schöpfer des Open-Source-KI-Agent-Projekts OpenClaw (das am schnellsten mit Sternen versehene neue Repository in der GitHub-Geschichte) – einen Tweet mit zwölf Zeichen:
„Du solltest Coding-Agents nicht mehr prompten. Du solltest Loops entwerfen, die deine Agents prompten.“
(Du solltest KI-Coding-Assistenten nicht mehr manuell prompten. Du solltest Loops entwerfen, die Agents sich selbst prompten lassen.)
- Prompt Engineeringbedeutet „der KI beizubringen, wie man Dinge tut“
- Loop Engineeringbedeutet „ein System zu entwerfen, in dem die KI kontinuierlich selbst Dinge tut“

Diese zwei Sätze lösten eine riesige Diskussion in der KI-Entwickler-Community aus, weil sie genau einen Trend beschrieben, den viele gespürt, aber noch nicht benannt hatten:Ob Prompts gut geschrieben sind, ist nicht mehr der Engpass; der Engpass liegt im gesamten laufenden System, das du für den Agent entwirfst.。
Anschließend veröffentlichte Addy Osmani einen langen Artikel auf Substack, in dem er diese Praxis formell alsLoop Engineeringbenannte und systematisierte und sie damit zu einer eigenständigen Engineering-Disziplin machte.
Hintergrund: Drei Generationen von KI-Programmierwerkzeugen
Loop-Engineering entstand nicht aus dem Nichts; es ist das natürliche Ergebnis der Entwicklung der Fähigkeiten von KI-Programmierwerkzeugen.
| Phase | Repräsentatives Werkzeug | Arbeitsweise | Engpass |
|---|---|---|---|
| Erste Generation: Autovervollständigung | Frühe Versionen von GitHub Copilot | Vervollständigt die aktuelle Zeile oder Funktion; Menschen treffen alle Entscheidungen | Kann nur unterstützen, nicht autonom handeln |
| Zweite Generation: Konversationell | ChatGPT、Claude.ai | Eine Frage stellen, eine Antwort erhalten; Menschen treiben jeden Schritt manuell voran | Menschen werden zum Engpass; die Geschwindigkeit ist durch die Tippgeschwindigkeit begrenzt |
| Dritte Generation: Autonomer Loop des Agenten | Claude Code、OpenAI Codex Agent | Der Agent plant, führt aus, verifiziert und iteriert autonom in einem Loop, bis die Aufgabe abgeschlossen ist | Wie man ein System entwirft, das Loops zuverlässig laufen lässt |
Die Entstehung von Werkzeugen der dritten Generation bedeutet, dass sich die Kernkompetenz eines Ingenieurs von der Formulierung von Prompts hin zum Entwurf von Loops verschoben hat.
Was ist Loop-Engineering
Loop-Engineering ist die Ingenieurspraxis, Feedback-Loops zu entwerfen, zu betreiben und kontinuierlich zu verbessern, die es KI-Coding-Agenten ermöglichen, autonom zu planen, Codeänderungen auszuführen, Ergebnisse zu beobachten und Aufgaben über mehrere Iterationen hinweg abzuschließen.
In einem Satz:
Loop-Engineering macht dich von „der Person, die dem Agenten Prompts gibt“ zu „dem Ingenieur, der das System entwirft, das dem Agenten Prompts gibt.“
Was ist ein Loop
Ein Loop ist ein rekursives Zielsystem: Du definierst einen Zweck, und der Agent iteriert, bis die Arbeit wirklich erledigt ist.
Jeder Agent hat bei der Ausführung von Aufgaben bereits einen eingebauten „inneren Loop“: Wahrnehmen → Schlussfolgern → Handeln → Beobachten, dann wieder von vorn.
Loop-Engineering arbeitet auf dernächsten Ebene oberhalb der:
| Schicht | Wer treibt an | Was getan wird |
|---|---|---|
| Innerer Loop (in den Agenten eingebaut) | Der Agent selbst | Datei lesen → Code ändern → Tests ausführen → Fehler lesen → erneut ändern |
| Äußerer Loop (von dir entworfen) | Das System, das du entwirfst | Aufgaben gemäß Plan entdecken → Agenten entsenden → Ergebnisse verifizieren → Status erfassen → nächste Runde starten |
Du sitzt nicht mehr neben dem Agenten und tippst für jeden Schritt einen Befehl ein. Du entwirfst ein externes System, das den inneren Loop für dich antreibt, während du die Dinge erledigst, die mehr Urteilsvermögen erfordern.
Der Unterschied zwischen Loop-Engineering und Prompt-Engineering
| Dimension | Prompt-Engineering | Loop Engineering |
|---|---|---|
| Optimierungsziel | Eine einzelne Anweisung, die du von Hand schreibst | Das gesamte System, das automatisch entscheidet, „was als Prompt gesendet wird, wann ein Prompt gesendet wird und ob das Ergebnis akzeptabel ist“ |
| Arbeitseinheit | Eine manuell eingegebene Konversationsrunde | Ein vollständiger Workflow, der mehrere Runden umfasst und automatisch läuft |
| Erfolgsmessung | Qualität der ersten Antwort | Qualität der endgültigen Ausgabe |
| Fehlermodus | Das Modell gibt eine schlechte Antwort | Der Loop des Systems ist schlecht entworfen: Der Loop stoppt zu früh, ignoriert Fehlersignale oder kann den Abschluss nicht verifizieren |
| Perspektive auf den Agenten | Ein Werkzeug, das du hältst | Ein lang laufender Prozess, den du einplanst |

Prompt-Engineering ist nicht tot. Ein Loop besteht aus mehreren Prompts, und schlecht geschriebene Prompts, die in einen Loop gesetzt werden, erzeugen nur schneller schlechte Arbeit. Loop-Engineering ist eine Ebene über Prompt-Engineering, kein Ersatz dafür.
Der vollständige dreischichtige Technologie-Stack:
| Ebene | Was optimiert wird | Arbeitseinheit |
|---|---|---|
| Prompt-Engineering | Wie eine einzelne Anweisung formuliert wird | Eine einzelne Konversation, die du manuell tippst |
| Context Engineering | Welche Inhalte in das Kontextfenster gelangen: Dokumente, Verlauf, Werkzeugdefinitionen | Die Umgebungsbedingungen rund um eine einzelne Antwort |
| Loop Engineering | Ein selbstlaufendes System, das entscheidet, was als Prompt gesendet wird, wann ein Prompt gesendet wird und ob Ergebnisse akzeptabel sind | Automatisierte Workflows, die mehrere innere Loops umfassen |
Der Kern-Loop
Die Grundstruktur eines Agent-Loops besteht aus fünf End-to-End-verbundenen Phasen, die kontinuierlich iterieren.
| Phase | Englischer Name | Was es tut | Typische Signalquellen |
|---|---|---|---|
| Absicht | Absicht | Das Zielergebnis definieren: Wie Erfolg aussieht, welche Einschränkungen gelten | Entwickler oder externes System (Issue, CI-Bericht) |
| Kontext | Kontext | Relevanten Code, Dokumentation, Fehlerprotokolle und Konventionen sammeln | Codebasis, Testausgabe, Gesprächsverlauf |
| Aktion | Aktion | Dateien bearbeiten, Befehle ausführen, Tools aufrufen, Pläne entwerfen | Agent führt autonom aus |
| Beobachtung | Beobachtung | Testergebnisse, Kompilierungsfehler, Laufzeitausgaben, Code-Diffs abrufen | Test-Framework, Type-Checker, CI, menschliche Überprüfung |
| Anpassung | Anpassung | Den Plan anhand der Beobachtungen aktualisieren, die Schleife wiederholen, bis die Aufgabe abgeschlossen oder blockiert ist | Nächste Runde der inneren Schleife |
Die Kraft eines Loops liegt nicht in einem einzelnen Schritt, sondern imgeschlossenen Kreislauf. Ein Testfehler ist nicht nur eine Fehlermeldung; er ist neuer Kontext. Ein Typfehler ist nicht nur ein Blocker; er ist ein Signal für eine falsche Annahme. Ein Code-Review-Kommentar ist nicht nur Feedback; er ist eine neue Beobachtung, die die nächste Aktion antreibt.
Sechs Kernkomponenten
Ein Loop, der wirklich unabhängig laufen kann, benötigt fünf Kernkomponenten sowie ein Gedächtnissystem, das durchgehend mitläuft. Keine davon darf fehlen.
Komponente 1: Automatisierungen
Automatisierungen sind der Herzschlag eines Loops. Ohne automatische Auslösung ist ein Loop nur "eine Operation, die du einmal ausgeführt hast", kein echter Zyklus.
Trigger definieren:Wann? Was tun?
In Claude Code verwendest du/loopden Befehl, um einen geplanten Loop zu erstellen:
Beispiel
# Ergebnisse in TODO.md schreiben und Fixes für als quick-win markierte Issues entwerfen
/loop "Gestrige CI-Fehler und offene Issues lesen, Ergebnisse schreiben \
in TODO.md, und Fixes für alles mit dem Label quick-win entwerfen" \
--schedule "0 9 * * 1-5"
# /goal: ausführen, bis eine überprüfbare Bedingung erfüllt ist
# Der folgende Befehl läuft weiter, bis alle Tests für das auth-Modul bestehen und lint sauber ist
/goal "Alle Tests in test/auth bestehen und lint ist sauber"
In OpenAI Codex haben Automations ein eigenes UI-Panel, in dem du das Projekt, den Prompt, die Taktung und ob in einem lokalen Checkout oder einem Hintergrund-Worktree ausgeführt werden soll, festlegen kannst. Läufe, die Inhalte finden, landen in einem Triage-Posteingang; Läufe, die nichts finden, werden automatisch archiviert.
Warnung zu Token-Kosten:Geplante Loops mit Verifizierungs-Sub-Agents verbrauchen bei jeder Auslösung Tokens, und der Verbrauch variiert stark mit der Aufgabenkomplexität. Es wird empfohlen, mit einer langsameren Taktung zu beginnen (z. B. einmal täglich), die Kosten einige Tage zu beobachten und dann die Frequenz zu erhöhen.
Komponente 2: Parallele Isolierung (Worktrees)
Wenn du mehrere Agents gleichzeitig ausführst, sind Dateikonflikte die wahrscheinlichste Problemquelle. Zwei Agents, die gleichzeitig in dieselbe Datei schreiben, sind wie zwei Ingenieure, die dieselbe Codezeile committen – das Ergebnis ist katastrophal.
Git Worktreeist die Lösung: Gib jedem Agenten sein eigenes Arbeitsverzeichnis, arbeite auf separaten Branches, teile dieselbe Git-Historie, aber halte Dateiänderungen vollständig isoliert.
Beispiel
git worktree add ../agent-fix-auth feature/fix-auth-tests
git worktree add ../agent-upgrade-deps feature/upgrade-axios
# In Claude Code die Worktree-Isolierung für Sub-Agents konfigurieren
# Zum Frontmatter von .claude/agents/reviewer.md hinzufügen:
# isolation: worktree → jeder Agent erhält einen unabhängigen Checkout, der nach Abschluss automatisch bereinigt wird
Worktrees beseitigen mechanische Dateikonflikte, aber sie könnenden Review-Engpassnicht beseitigen. Die Geschwindigkeit, mit der du Codeänderungen bearbeitest und genehmigst, ist die eigentliche Obergrenze dafür, wie viele Agents du parallel ausführen kannst, nicht wie viele Worktrees das Tool öffnen kann.
Komponente 3: Skill-Dateien
Skills (Skill-Dateien) beheben einen Kostenpunkt, der jedes Mal verschwendet wird:Bei jeder neuen Konversation muss der Agent deine Projektkonventionen von Grund auf neu ableiten。
Ein Skill ist ein Paket, das Folgendes enthältSKILL.mdDer Ordner mit Dateien, der Projektkonventionen, Build-Schritte und Wissen wie "wir machen das nicht so wegen dieses Vorfalls" dokumentiert. Der Agent lädt den Skill zu Beginn jeder Sitzung, statt jedes Mal neu zu raten.
Beispiel
---
name: project-conventions
description: Projekt-Codierungsstandards und Build-Schritte. Jede Aufgabe, die Codeänderungen umfasst, sollte diesen Skill laden.
---
## Tech-Stack
- Backend: Node.js20 + TypeScript 5.4 + Fastify
- Datenbank: PostgreSQL16, ORM verwendet Drizzle
- Tests: Vitest, Testdateien liegen unter __tests__/ auf derselben Ebene wie src/
## Build-Befehle
- Abhängigkeiten installieren: pnpm install
- Tests ausführen: pnpm test
- Typüberprüfung: pnpm typecheck
- Build-Artefakte: pnpm build
## Kernkonventionen
- Alle Datenbankabfragen müssen über Wrapper-Funktionen in src/db/queries/ laufen; direktes Schreiben von rohem SQL in der Business-Schicht ist verboten
- Für Fehler einheitlich die AppError-Klasse verwenden (src/errors/AppError.ts); das Werfen einfacher Strings ist verboten
- Benennung von API-Routendateien:{resource}.routes.ts, abgelegt in src/routes/
- Bei neuen APIs muss auch docs/api.md aktualisiert werden
## Verbote
- Historische Migrationsdateien im Verzeichnis migrations/ dürfen nicht direkt geändert werden
- Keine echten Secrets in der .env-Datei committen; .env.example als Platzhalter verwenden
Komponente 4: Konnektoren / MCP
Ein Loop, der nur das lokale Dateisystem sehen kann, kann nur sehr begrenzte Dinge tun. Konnektoren (basierend auf MCP—Model Context Protocol) ermöglichen es dem Agenten, Issue-Tracker zu lesen, Datenbanken abzufragen, APIs aufzurufen und Nachrichten in Slack zu senden.
Das ist der entscheidende Unterschied zwischen "der Agent sagt 'hier ist der Fix'" und "der Loop öffnet automatisch einen PR, verknüpft das Ticket und benachrichtigt den Kanal, nachdem CI bestanden ist."
Sowohl Claude Code als auch OpenAI Codex unterstützen das MCP-Protokoll nativ, und Konnektoren, die für ein Tool geschrieben wurden, können im Allgemeinen in beiden verwendet werden.
Beispiel: MCP-Konnektoren in Claude Code konfigurieren
// MCP-Konnektoren konfigurieren, damit der Agent GitHub bedienen und Slack-Benachrichtigungen senden kann
{
"connectors": [
{
"name": "github",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "${GITHUB_TOKEN}"
}
},
{
"name": "slack",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"
}
}
]
}
Konnektoren mit dem Agenten zu verbinden bedeutet, dass er echte Aktionen in echten Umgebungen ausführen kann. Jeder Konnektor muss mit geringsten Rechten konfiguriert werden, und risikoreiche Vorgänge (Code pushen, PRs mergen, externe Benachrichtigungen senden) müssen eine menschliche Genehmigung erfordern; sie dürfen nicht vollständig automatisch ausgeführt werden.
Komponente 5: Sub-Agenten
Eine der wichtigsten Architekturentscheidungen im Loop:Trenne den Agenten, der Code schreibt, von dem Agenten, der Code prüft。
Das Modell, das den Code geschrieben hat, ist zu nachsichtig, wenn es seine eigene Arbeit bewertet. Ein unabhängiger Prüfer mit anderen Anweisungen – manchmal unter Verwendung eines anderen Modells – kann Probleme erkennen, die der erste Agent wegrationalisiert hat.
Dieses "Maker-Checker"-Muster wird auch auf die Abbruchbedingung des Loops angewendet: Claude Codes/goalBefehl verwendet nach jeder Iteration ein separates Modell, um zu beurteilen, ob es "fertig" ist, anstatt das Modell, das die Arbeit erledigt hat, dieses Urteil fällen zu lassen.
Beispiel: Definieren eines Reviewer-Sub-Agenten
---
name: spec-reviewer
description: Führe eine adversariale Überprüfung abgeschlossener Codeänderungen durch, um zu verifizieren, dass sie die Spezifikationen und Testanforderungen erfüllen.
model: opus # Verwende ein stärkeres Modell als Verifizierer
isolation: worktree # Unabhängig auschecken, um den Arbeitsbereich des Erstellers nicht zu verschmutzen
---
Du bist ein adversarialer Code-Reviewer. Deine Aufgabe ist es nicht, zu genehmigen, sondern zu hinterfragen.
Nachdem du einen Diff erhalten hast, musst du:
1. Führe die vollständige Testsuite aus (pnpm test), zeichne Fehler auf
2. Führe die Typüberprüfung aus (pnpm typecheck)
3. Vergleiche den Diff mit den Projektspezifikationen in SKILL.md
4. Verifiziere, dass benutzersichtbare Verhaltensänderungen die ursprünglichen Anforderungen erfüllen
Gib nur dann APPROVED aus, wenn alle Tests bestehen, die Typüberprüfung sauber ist und keine Spezifikationsverletzungen vorliegen.
Andernfalls gib spezifische Ablehnungsgründe aus; gib kein vages Feedback.
Komponente 6: Persistenter Speicher
Der Speicher ist die tragende Säule jedes Loops, der über Gespräche hinweg dauerhaft ausgeführt werden kann.
Das Modell vergisst zwischen Konversationen vollständig. Ohne externen Speicher beginnt der Agent jedes Mal, wenn der Loop ausgelöst wird, bei Null und weiß nicht, was gestern getan wurde, welche Fehlerbehebungen zusammengeführt wurden und welche Aufgaben noch offen sind.
Die Lösung ist extrem einfach:Schreibe den Zustand in Dateien und bewahre die Dateien im Repository auf.. Das Repository erinnert sich, auch wenn das Modell es nicht tut.
Beispiel: Loop-Statusdatei
# Loop-Aufgabenstatus
Zuletzt aktualisiert:2026-06-1409:03 UTC (aktualisiert durch automatischen Loop)
## In Bearbeitung
- [ ]Instabiler Test in test/auth/login.spec.ts (CI-Lauf#4821, 3 Mal fehlgeschlagen)
- Hypothese: Sitzungszustands-Leck zwischen gleichzeitigen Tests
- Versucht: Isolieren der Testdatenbankverbindung → unwirksam
- Nächster Schritt: Aufräumlogik in beforeEach überprüfen
## Ausstehend
- [ ]Aktualisiere axios auf1.7.x (Sicherheitslücke CVE-2026-xxxxx)
- [ ]Aktualisierung der API-Dokumentation (PR#308 ist nach dem Merge hinter dem Code zurück)
## Abgeschlossen
- [x]Behob das Abrechnungsmodul [Problem], das durch Firmennamen mit einfachen Anführungszeichen verursacht wurde500Fehler (PR#312, zusammengeführt)
- [x]Aktualisiere Node.js-Version auf20.x(PR #307, zusammengeführt)
Fünf gängige Loop-Muster
Verschiedene Arten von Aufgaben erfordern unterschiedliche Rückmeldesignale und Abbruchbedingungen, daher haben sich mehrere klassische Loop-Muster herausgebildet.
| Muster | Zentrales Beobachtungssignal | Abbruchbedingung | Typisches Szenario |
|---|---|---|---|
| Testgetriebener Loop | Test bestanden / fehlgeschlagen | Alle Zieltests bestanden | Fehlerbehebungen, Regressionstests, Datenumwandlungslogik |
| Compilergetriebener Loop | Typfehler, Liste der Kompilierungsfehler | Null Typüberprüfungsfehler | TypeScript-Migration, Abhängigkeitsaktualisierungen, Refactoring |
| Reviewgetriebener Loop | Menschliche Review-Kommentare | Alle Kommentare bearbeitet oder als ignoriert dokumentiert | Mechanische Nachverfolgung von PR-Reviews |
| Laufzeit-Debugging-Loop | Logs, Stack-Traces, HTTP-Antworten | Problem reproduzieren → Hypothese bilden → Fix verifizieren | Produktionsfehler, Leistungsprobleme, API-Ausnahmen |
| Produktiterations-Loop | Screenshots, Browser-Prüfungen, Barrierefreiheitsberichte | Ausgerichtet an Design-Mockups, responsive korrekt, keine Spezifikationsverletzungen | Landing Pages, UI-Anpassungen, Marketing-Komponenten |
Deinen ersten Loop erstellen
Versuche nicht, von Anfang an einen vollautomatisierten Multi-Agenten-Loop zu bauen, der PRs automatisch zusammenführt. Beginne mit dem kleinsten nutzbaren Loop, verstehe sein Verhalten und erweitere ihn dann schrittweise.
Schritt 1: Beginne mit einer eng gefassten Aufgabe
Je enger die Aufgabe gefasst ist, desto klarer ist dem Agenten, welche Dateien relevant sind und welche Validierungssignale eine Rolle spielen.
| Schlechte Aufgabenstellung | Gute Aufgabendefinition |
|---|---|
| "Dashboard-Leistung optimieren" | "Die anfängliche Ladezeit des Dashboards um 30% reduzieren, indem das Laden nicht kritischer Diagramme aufgeschoben wird, während bestehende Filter weiter funktionieren" |
| "Checkout-Probleme beheben" | "Den fehlschlagenden Test zur Steuerberechnung in test/checkout/tax.spec.ts beheben" |
| "Die Einstellungsseite verbessern" | "Das Layoutproblem beheben, bei dem die Schaltfläche zum Löschen des Kontos auf Mobilgeräten (375px Breite) abgeschnitten wird" |
Schritt 2: Die Verifizierungsmethode klar angeben
Der Loop muss wissen, was "fertig" bedeutet. Wenn du den Verifizierungsbefehl kennst, schreibe ihn direkt in die Anweisungen.
Beispiel: Loop-Anweisungen mit Verifizierungsbedingungen
/goal "Den Auth-Bug beheben"
# Gut: hat spezifische Verifizierungsbefehle und Erfolgskriterien
/goal "Das Session-Leck beheben, das flaky Tests in test/auth/login.spec.ts verursacht.
Erfolgsbedingung: Führe 'pnpm test test/auth/login.spec.ts' 5 Mal aus
hintereinander ohne Fehler. Ändere keine anderen Testdateien."
Schritt 3: Sicherheitsmechanismen einrichten
Bevor der Loop automatisch PRs öffnen kann, soll er nur Dateien schreiben und keine externen Aktionen ausführen; du prüfst den Diff und entscheidest, ob committet wird.
Beispiel: Täglicher CI-Fehler-Triage-Loop (minimale sichere Version)
# - Schreibgeschützte Operationen (CI-Logs lesen, Issues lesen)
# - Nur TODO.md schreiben (keine anderen Dateien anfassen)
# - Keine PRs, keine Code-Merges
# - Du prüfst TODO.md jeden Morgen und entscheidest manuell über den nächsten Schritt
/loop "Lies die CI-Fehlerprotokolle von gestern und GitHub-Issues mit dem Label 'bug'.
Kategorisiere die Ergebnisse nach wahrscheinlicher Ursache.
Schreibe eine Zusammenfassung mit priorisierten Maßnahmen in TODO.md.
Bearbeite KEINE Quelldateien. Öffne KEINE PRs." \
--schedule "0 8 * * 1-5"
Diese minimale Version des Loops ist bereits wertvoll: Sie organisiert jeden Morgen die gestrige Issue-Liste für dich, und wenn du ins Büro kommst, kannst du TODO.md öffnen und weißt, was heute zu tun ist, anstatt eine halbe Stunde damit zu verbringen, CI-Logs zu durchwühlen. Dies ist der beste Ausgangspunkt, um das Loop-Verhalten zu verstehen, mit nahezu null Risiko.
Schritt 4: Autonomie schrittweise erhöhen
| Phase | Was der Loop tun kann | Was der Mensch tut |
|---|---|---|
| Stufe 1 (schreibgeschützt) | Probleme erkennen, Aufgaben triagieren, Statusdateien schreiben | TODO.md prüfen, manuell die Reihenfolge der Bearbeitung entscheiden |
| Stufe 2 (Entwurf) | Korrekturen entwerfen, Tests ausführen, in einen Branch schreiben | Den Diff prüfen, git push manuell ausführen |
| Stufe 3 (halbautomatisch) | Einen Draft-PR öffnen, CI ausführen, Slack benachrichtigen | Den PR prüfen, manuell auf Merge klicken |
| Stufe 4 (vollautomatisch) | Producer- + Reviewer-Dual-Agenten, Auto-Merge nach bestandenem CI | Menschliches Eingreifen bei Anomalien, regelmäßige Prüfung der Merge-Historie |
Drei große Risiken des Loop-Engineerings
Loop verändert die Art und Weise, wie du arbeitest, aber er beseitigt nicht die Verantwortung des Engineers. Es gibt drei Probleme, die schwerwiegender werden, je besser Loop wird, nicht einfacher.
Risiko 1: Verifizierung bleibt deine Verantwortung
Ein Loop, der unbeaufsichtigt läuft, ist auch ein Loop, der unbeaufsichtigt Fehler macht. Einen Reviewer-Sub-Agenten einzurichten ist eine gute Möglichkeit, das Risiko zu verringern, aber "bestandene Verifizierung" ist eine Behauptung, kein Beweis.
Egal wie zuverlässig der Loop ist, die menschliche Überprüfung von gemergtem Code darf nicht verschwinden.
Risiko 2: Verständnisschuld sammelt sich schneller an
Je schneller Loop Code produziert, desto geringer ist der Anteil des Codes, den du tatsächlich verstehst. Das ist kein Problem, das nur die KI-Programmierung betrifft, aber Loop hat es beschleunigt.
Das einzige Gegenmittel ist:Lies den Code, den der Loop erzeugtHöre nicht auf zu verstehen, was er tut, nur weil der Loop reibungslos läuft.
Risiko 3: Kognitive Kapitulation
Wenn der Loop automatisch läuft, ist es die bequemste Wahl, jedes Ergebnis zu akzeptieren, das er zurückgibt. Dies ist die am besten verborgene Gefahr des Loop-Engineerings.
Zwei Personen können exakt denselben Loop bauen und dennoch völlig entgegengesetzte Ergebnisse erzielen: Die eine nutzt ihn, um auf Basis tiefen Verständnisses schneller voranzukommen, die andere nutzt ihn, um die Arbeit des Verstehens selbst zu vermeiden. Der Loop kennt den Unterschied nicht. Du schon.
Vier Arten von Loop-Fehlermodi und Gegenmaßnahmen:
| Fehlermodus | Symptome | Grundursache | Lösung |
|---|---|---|---|
| Rastloses Ändern | Der Agent ändert wiederholt Code, konvergiert aber nicht | Unklare Ziele, verrauschte Verifikationssignale oder zu großer Umfang jeder Änderung | Zielumfang verengen, Größe jedes Diffs reduzieren, zuverlässigere Verifikationsbefehle verwenden |
| Überangepasste Tests | Alle Tests bestehen, aber die Funktionalität ist tatsächlich falsch | Testabdeckung ist zu gering, reale Nutzerszenarien werden nicht verifiziert | Automatisierte Tests mit manuellen Abnahmeprüfungen kombinieren, End-to-End-Tests hinzufügen |
| Kontext-Drift | Der Agent arbeitet weiter auf Basis veralteter Annahmen und ignoriert neu auftretende Änderungen | Kontext wird nach wichtigen Beobachtungen nicht aktualisiert | Nach wichtigen Beobachtungen den Kontext neu erfassen; den ursprünglichen Plan nicht als heilig betrachten |
| Unsichere Autonomie | Der Agent führt destruktive Operationen ohne Autorisierung aus | Berechtigungsumfang zu weit gefasst, ohne klare Abbruchbedingungen | Prinzip der minimalen Berechtigung; Hochrisiko-Operationen erfordern menschliche Genehmigung; klare Abbruchregeln festlegen |
Zusammenfassung der Best Practices
Im Folgenden sind Kernprinzipien für den Aufbau zuverlässiger Loops aufgeführt; jedes entspricht einer häufigen Fehlerklasse.
| Prinzipien | Konkrete Praktiken |
|---|---|
| Mit eng gefassten Aufgaben beginnen | Definiere jeweils nur ein klar abgegrenztes Ziel; breite Ziele machen es dem Agenten unmöglich zu bestimmen, welche Dateien und welche Validierungssignale relevant sind |
| Dem Agenten sagen, wie validiert werden soll | Schreibe den Validierungsbefehl direkt in die Anweisungen (pnpm test test/auth), Abnahmeszenarien oder API-Endpunkte, sodass "Fertigstellung" messbar wird |
| Kleine, umkehrbare Änderungen bevorzugen | Verlange vom Agenten, die kleinste kohärente Änderung vorzunehmen, Validierung auszuführen und dann zu erweitern; umfangreiche spekulative Umschreibungen machen es schwer zu erkennen, welche Annahme falsch war |
| Bestehende Codemuster respektieren | Lass den Agenten zuerst benachbarte Implementierungen prüfen, bestehende Komponenten wiederverwenden, bestehenden Namenskonventionen folgen und unnötige neue Abstraktionen vermeiden |
| Menschen in der Entscheiderrolle lassen | Der Agent übernimmt Beweissammlung und mechanische Korrekturen; Produkturteil, Architekturentscheidungen und abschließende Prüfung bleiben bei Menschen |
| Wiederverwendbare Loops kodifizieren | Wenn ein Loop gut läuft, verfestige ihn zu einer Skill-Datei oder einem standardisierten Auslöser, um zukünftige Wiederholungskosten zu senken |