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.

PhaseRepräsentatives WerkzeugArbeitsweiseEngpass
Erste Generation: AutovervollständigungFrühe Versionen von GitHub CopilotVervollständigt die aktuelle Zeile oder Funktion; Menschen treffen alle EntscheidungenKann nur unterstützen, nicht autonom handeln
Zweite Generation: KonversationellChatGPT、Claude.aiEine Frage stellen, eine Antwort erhalten; Menschen treiben jeden Schritt manuell voranMenschen werden zum Engpass; die Geschwindigkeit ist durch die Tippgeschwindigkeit begrenzt
Dritte Generation: Autonomer Loop des AgentenClaude Code、OpenAI Codex AgentDer Agent plant, führt aus, verifiziert und iteriert autonom in einem Loop, bis die Aufgabe abgeschlossen istWie 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:

SchichtWer treibt anWas getan wird
Innerer Loop (in den Agenten eingebaut)Der Agent selbstDatei lesen → Code ändern → Tests ausführen → Fehler lesen → erneut ändern
Äußerer Loop (von dir entworfen)Das System, das du entwirfstAufgaben 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

DimensionPrompt-EngineeringLoop Engineering
OptimierungszielEine einzelne Anweisung, die du von Hand schreibstDas gesamte System, das automatisch entscheidet, „was als Prompt gesendet wird, wann ein Prompt gesendet wird und ob das Ergebnis akzeptabel ist“
ArbeitseinheitEine manuell eingegebene KonversationsrundeEin vollständiger Workflow, der mehrere Runden umfasst und automatisch läuft
ErfolgsmessungQualität der ersten AntwortQualität der endgültigen Ausgabe
FehlermodusDas Modell gibt eine schlechte AntwortDer Loop des Systems ist schlecht entworfen: Der Loop stoppt zu früh, ignoriert Fehlersignale oder kann den Abschluss nicht verifizieren
Perspektive auf den AgentenEin Werkzeug, das du hältstEin 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:

EbeneWas optimiert wirdArbeitseinheit
Prompt-EngineeringWie eine einzelne Anweisung formuliert wirdEine einzelne Konversation, die du manuell tippst
Context EngineeringWelche Inhalte in das Kontextfenster gelangen: Dokumente, Verlauf, WerkzeugdefinitionenDie Umgebungsbedingungen rund um eine einzelne Antwort
Loop EngineeringEin selbstlaufendes System, das entscheidet, was als Prompt gesendet wird, wann ein Prompt gesendet wird und ob Ergebnisse akzeptabel sindAutomatisierte 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.

PhaseEnglischer NameWas es tutTypische Signalquellen
AbsichtAbsichtDas Zielergebnis definieren: Wie Erfolg aussieht, welche Einschränkungen geltenEntwickler oder externes System (Issue, CI-Bericht)
KontextKontextRelevanten Code, Dokumentation, Fehlerprotokolle und Konventionen sammelnCodebasis, Testausgabe, Gesprächsverlauf
AktionAktionDateien bearbeiten, Befehle ausführen, Tools aufrufen, Pläne entwerfenAgent führt autonom aus
BeobachtungBeobachtungTestergebnisse, Kompilierungsfehler, Laufzeitausgaben, Code-Diffs abrufenTest-Framework, Type-Checker, CI, menschliche Überprüfung
AnpassungAnpassungDen Plan anhand der Beobachtungen aktualisieren, die Schleife wiederholen, bis die Aufgabe abgeschlossen oder blockiert istNä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

# Jeden Wochentag um 9 Uhr ausführen: gestrige CI-Fehler und Issues lesen,
# 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

# Manuell einen Worktree erstellen (sowohl Claude Code als auch Codex unterstützen die automatische Verwaltung)
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

<!-- Dateipfad: .claude/skills/project-conventions/SKILL.md -->
---
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

// Dateipfad: .claude/mcp.json
// 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

<!-- Dateipfad: .claude/agents/spec-reviewer.md -->
---
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

<!-- Dateipfad: TODO.md (Loop-Statusdatei, zusammen mit dem Code committet) -->
# 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.

MusterZentrales BeobachtungssignalAbbruchbedingungTypisches Szenario
Testgetriebener LoopTest bestanden / fehlgeschlagenAlle Zieltests bestandenFehlerbehebungen, Regressionstests, Datenumwandlungslogik
Compilergetriebener LoopTypfehler, Liste der KompilierungsfehlerNull TypüberprüfungsfehlerTypeScript-Migration, Abhängigkeitsaktualisierungen, Refactoring
Reviewgetriebener LoopMenschliche Review-KommentareAlle Kommentare bearbeitet oder als ignoriert dokumentiertMechanische Nachverfolgung von PR-Reviews
Laufzeit-Debugging-LoopLogs, Stack-Traces, HTTP-AntwortenProblem reproduzieren → Hypothese bilden → Fix verifizierenProduktionsfehler, Leistungsprobleme, API-Ausnahmen
Produktiterations-LoopScreenshots, Browser-Prüfungen, BarrierefreiheitsberichteAusgerichtet an Design-Mockups, responsive korrekt, keine SpezifikationsverletzungenLanding 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 AufgabenstellungGute 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

# Schlecht: keine Verifizierungsbedingung, der Agent weiß nicht, wann er aufhören soll
/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)

# Dies ist der empfohlene erste Loop:
# - 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

PhaseWas der Loop tun kannWas der Mensch tut
Stufe 1 (schreibgeschützt)Probleme erkennen, Aufgaben triagieren, Statusdateien schreibenTODO.md prüfen, manuell die Reihenfolge der Bearbeitung entscheiden
Stufe 2 (Entwurf)Korrekturen entwerfen, Tests ausführen, in einen Branch schreibenDen Diff prüfen, git push manuell ausführen
Stufe 3 (halbautomatisch)Einen Draft-PR öffnen, CI ausführen, Slack benachrichtigenDen PR prüfen, manuell auf Merge klicken
Stufe 4 (vollautomatisch)Producer- + Reviewer-Dual-Agenten, Auto-Merge nach bestandenem CIMenschliches 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:

FehlermodusSymptomeGrundursacheLösung
Rastloses ÄndernDer Agent ändert wiederholt Code, konvergiert aber nichtUnklare Ziele, verrauschte Verifikationssignale oder zu großer Umfang jeder ÄnderungZielumfang verengen, Größe jedes Diffs reduzieren, zuverlässigere Verifikationsbefehle verwenden
Überangepasste TestsAlle Tests bestehen, aber die Funktionalität ist tatsächlich falschTestabdeckung ist zu gering, reale Nutzerszenarien werden nicht verifiziertAutomatisierte Tests mit manuellen Abnahmeprüfungen kombinieren, End-to-End-Tests hinzufügen
Kontext-DriftDer Agent arbeitet weiter auf Basis veralteter Annahmen und ignoriert neu auftretende ÄnderungenKontext wird nach wichtigen Beobachtungen nicht aktualisiertNach wichtigen Beobachtungen den Kontext neu erfassen; den ursprünglichen Plan nicht als heilig betrachten
Unsichere AutonomieDer Agent führt destruktive Operationen ohne Autorisierung ausBerechtigungsumfang zu weit gefasst, ohne klare AbbruchbedingungenPrinzip 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.

PrinzipienKonkrete Praktiken
Mit eng gefassten Aufgaben beginnenDefiniere 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 sollSchreibe den Validierungsbefehl direkt in die Anweisungen (pnpm test test/auth), Abnahmeszenarien oder API-Endpunkte, sodass "Fertigstellung" messbar wird
Kleine, umkehrbare Änderungen bevorzugenVerlange 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 respektierenLass den Agenten zuerst benachbarte Implementierungen prüfen, bestehende Komponenten wiederverwenden, bestehenden Namenskonventionen folgen und unnötige neue Abstraktionen vermeiden
Menschen in der Entscheiderrolle lassenDer Agent übernimmt Beweissammlung und mechanische Korrekturen; Produkturteil, Architekturentscheidungen und abschließende Prüfung bleiben bei Menschen
Wiederverwendbare Loops kodifizierenWenn ein Loop gut läuft, verfestige ihn zu einer Skill-Datei oder einem standardisierten Auslöser, um zukünftige Wiederholungskosten zu senken
Weitere Erweiterungen