So erstellen Sie 2026 Ihren ersten KI-Loop

Zwei der erfahrensten KI-Entwickler der Welt sagten letzten Monat dasselbe.

Peter Steinberger, Entwickler von OpenClaw, jetzt bei OpenAI:

"Du solltest keine Coding-Agenten mehr prompten. Du solltest Loops entwerfen, die deine Agenten prompten."

Boris Cherny, Leiter von Claude Code bei Anthropic:

"Ich prompte Claude nicht mehr. Ich habe Loops, die Claude prompten und herausfinden, was zu tun ist. Meine Aufgabe ist es, Loops zu schreiben."

Die meisten Leser dachten: Was bedeutet das eigentlich?

Und noch wichtiger: Wie baue ich so einen Loop?

Dieser Artikel erklärt dir genau, wie.

Keine Theorie ohne Code. Kein Code ohne Kontext. Echte Schritte. Echte Befehle. Kopieren und ausführen.

Slate orchestriert GPT-5.6, Claude und spezialisierte Subagenten bei einer echten Migrationsaufgabe. Das Modell wurde intelligenter. Die größere Veränderung ist, dass Tools wie Slate diese Modelle endlich kontinuierlich beschäftigen können, anstatt auf menschliche Prompts zu warten.

Die Art, wie die meisten Leute KI nutzen, ist bereits veraltet

Prompt schreiben. Warten. Ausgabe lesen. Manuell korrigieren. Nächsten Prompt schreiben.

Du bist der Loop.

Jeder Schritt läuft über dich. Die KI wartet. Du entscheidest. Die KI wartet wieder.

In dem Moment, in dem du aufhörst, hört alles auf.

Die Entwickler, die 2026 am schnellsten vorankommen, schreiben keine besseren Prompts.

Sie bauen Systeme, die das Prompter für sie erledigen.

Der Hebelpunkt hat sich verschoben.

Vom Tippen von Prompts → zum Entwerfen von Loops.

Was hat sich mit GPT-5.6 geändert?

GPT-5.6 ändert nichts an der Notwendigkeit von Loops.

Es erhöht ihren Wert.

Je besser das Modell wird, desto teurer wird es, es zwischen den Prompts im Leerlauf zu lassen.

In Terminal-Workflows ist GPT-5.6 merklich besser bei:

→ Verstehen großer Codebasen

→ Aufrechterhalten der Implementierungskonsistenz

→ Befolgen von Multi-Step-Plänen

→ Erholen von fehlgeschlagenen Versuchen

→ Agieren als strenger Verifizierer

Das Ergebnis ist nicht "besseres Prompting."

Es sind weniger menschliche Eingriffe pro Aufgabe.

Was ein Loop eigentlich ist

Einfache Definition:

Ein Prompt antwortet einmal und hört auf.

Ein Loop arbeitet weiter, bis die Aufgabe tatsächlich erledigt ist.

Nicht bis eine Antwort generiert wurde.

Bis ein verifiziertes Ergebnis erreicht ist.

Jeder ernsthafte KI-Agent durchläuft denselben grundlegenden Zyklus:

→ Entdecken — Was muss getan werden?

→ Ausführen — Die Arbeit erledigen

→ Verifizieren — Hat es tatsächlich funktioniert?

→ Iterieren — Nicht erledigt? Korrigieren und wiederholen

→ Stoppen — Bedingung erfüllt oder hartes Limit erreicht

Claude Code. Cursor. Codex.

Im Kern laufen sie alle diesen Loop.

Der Unterschied zwischen einem Prompt und einem Loop ist nicht das Modell.

Es ist, ob etwas die Arbeit überprüft und weitermacht, bis sie bestanden ist.

Der 4-Bedingungen-Test — führe das aus, bevor du etwas baust

Die meisten Loops scheitern hier.

Ein Loop verdient seine Einrichtungskosten nur, wenn alle 4 Bedingungen erfüllt sind.

Fehlt eine, kostet der Loop mehr, als er einbringt.

1. Die Aufgabe wiederholt sich. Mindestens wöchentlich. Eine einmalige Aufgabe ist immer noch mit einem guten Prompt besser bedient.

2. Die Verifikation ist automatisiert. Etwas muss die Arbeit ablehnen können, ohne dass du im Raum bist. Tests. Linter. Builds. Typprüfungen. Keine Kontrollinstanz = der Agent benotet seine eigenen Hausaufgaben.

3. Dein Token-Budget kann die Verschwendung verkraften. Loops lesen bei jeder Iteration den gesamten Kontext neu. Sie wiederholen, erkunden, verbrennen Token, egal ob der Durchlauf etwas ausliefert oder nicht. Das sind die Kosten, die niemand erwähnt.

4. "Erledigt" ist objektiv. Ein Test, der bestanden oder nicht bestanden wird. Ein Build, der kompiliert oder nicht. Nicht "wenn es gut aussieht." Wenn "erledigt" eine menschliche Meinung erfordert, lass es manuell.

Alle 4 erfüllt → baue den Loop.

Scheitert eine → verwende stattdessen einen Prompt.

Die ehrliche Version: Die meisten Entwickler brauchen noch keine schweren Loops. Was jeder nutzen kann, ist ein einfacher Loop. Wir werden gleich einen bauen.

Slate installieren

Slate ist ein KI-Coding-Agent, der genau dafür gebaut wurde — lange, parallele, mehrstufige Aufgaben in deinem Terminal auszuführen.

Entwickelt von RandomLabs. Der erste Agent, der speziell für Schwarm-Orchestrierung entwickelt wurde.

Was ihn von Claude Code oder Cursor unterscheidet:

→ Wählt automatisch das richtige Modell für jeden Schritt aus. Plane mit Claude, suche mit einem anderen, führe mit Codex aus — Slate entscheidet.

→ Führt parallele Subagenten gleichzeitig in deiner Codebasis aus

→ Verwaltet seinen eigenen Kontext über lange, mehrstündige Sitzungen hinweg

→ Arbeitet mit dir zusammen — nicht nur für dich

Installiere es mit einer Zeile:

1npm i -g @randomlabs/slate

Navigiere zu deinem Projekt und starte es:

1cd /pfad/zu/deinem/projekt
2slate

Das öffnet die Slate TUI — eine Terminal-Oberfläche, in der du Aufgaben gibst und zusiehst, wie es arbeitet.

Schritt 1 — Richte deinen Arbeitsbereich ein

Bevor Slate Loops in deinem Projekt ausführen kann, muss es deine Codebasis verstehen.

Erstelle eine AGENTS.md-Datei im Stammverzeichnis deines Projekts. Dies ist der Kontext, den Slate zu Beginn jeder Sitzung liest.

1# AGENTS.md
2
3## Was diese Codebasis tut
4[Ein-Absatz-Beschreibung des Projekts]
5
6## Architektur
7- src/api/ — Express API-Routen
8- src/services/ — Geschäftslogik
9- src/db/ — Datenbankmodelle (PostgreSQL via Prisma)
10- tests/ — Jest-Testsuite
11
12## Wichtige Befehle
13- npm test — führt die gesamte Testsuite aus
14- npm run build — TypeScript-Kompilierung
15- npm run lint — ESLint-Prüfung
16- npm run typecheck — tsc --noEmit
17
18## Regeln
19- Ändere niemals src/billing/ oder src/auth/ ohne menschliche Genehmigung
20- Führe immer Tests aus, bevor du eine Aufgabe als abgeschlossen markierst
21- Verwende das bestehende Fehlerbehandlungsmuster in src/utils/errors.ts
22
23## Umgebung
24- .env.slate enthält alle Umgebungsvariablen, die Slate benötigt

Slate liest diese Datei automatisch beim Start — kein erneutes Einfügen bei jeder Sitzung erforderlich.

Füge deine Arbeitsbereichsverzeichnisse in Slate hinzu:

1/workspace add ./src
2/workspace add ./tests
3/workspace list

Oder verweise mit @-Erwähnungen inline auf bestimmte Dateien:

1Bitte überprüfe @src/api/routes.ts und schlage Verbesserungen vor

Schritt 2 — Slate konfigurieren

Erstelle slate.json im Stammverzeichnis deines Projekts, um das Verhalten von Slate zu steuern.

1{
2  "$schema": "https://randomlabs.ai/config.json",
3  "permission": {
4    "*": "allow",
5    "bash": "ask"
6  },
7  "models": {
8    "main": { "default": "anthropic/claude-opus-4.6" },
9    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
10    "search": { "default": "anthropic/claude-haiku-4.5" },
11    "reasoning": { "default": "openai/gpt-5.6" }
12  }
13}

Was das bewirkt:

→ "*": "allow" — Slate kann Dateien lesen und schreiben, ohne jedes Mal zu fragen

→ "bash": "ask" — Slate fragt, bevor es Shell-Befehle ausführt (lass dies eingeschaltet, bis du ihm vertraust)

→ Models-Konfiguration — günstiges, schnelles Modell für die Suche, teures Modell für die Hauptlogik

Für CI- oder Automatisierungsläufe, bei denen keine Eingabeaufforderungen gewünscht sind:

1slate run "Führe die Testsuite aus und behebe alle Fehler" --dangerously-skip-permissions --output-format stream-json

Schritt 3 — Deine erste Aufgabe (noch kein Loop)

Bevor du einen Loop baust, stelle sicher, dass ein einzelner manueller Durchlauf zuverlässig funktioniert.

Dies ist der am häufigsten übersprungene Schritt. Und der Grund, warum die meisten Loops in der Produktion scheitern.

Gib Slate eine echte Aufgabe:

1Bitte überprüfe die Architektur meiner gesamten Codebasis.
2Erstelle eine ARCH.md mit:
3- aktueller Struktur
4- Abhängigkeiten zwischen Modulen
5- 3 Verbesserungsmöglichkeiten
6Sieh dir zuerst @src/ an, dann @tests/

Sieh zu, wie Slate arbeitet. Es wird:

1. Deine Dateien durchsuchen
2. Ein Verständnis der Architektur aufbauen
3. Die ARCH.md entwerfen
4. Sie vor dem Stoppen gegen deine Anfrage prüfen

Dies ist bereits ein Mini-Loop — es überprüft seine eigene Ausgabe, bevor es fertig ist.

Für eine längere Aufgabe:

1Hey Slate, recherchiere meine Codebasis für den Authentifizierungsablauf,
2dann erstelle einen Plan zum Hinzufügen von OAuth2-Unterstützung.
3Stelle sicher, dass du dir @src/auth/ und @src/api/routes.ts ansiehst

Slate gibt einen Plan zurück. Du iterierst darauf:

1Nein, füge keine neue Auth-Provider-Klasse hinzu.
2Lass es dem gleichen Muster folgen wie das bestehende ApiKeyAuth in src/auth/api-key.ts

Genehmige den Plan. Slate führt autonom aus.

Schritt 4 — Erstelle eine Skill (mache den Loop wiederverwendbar)

Eine Skill ist, wie du aufhörst, dein Projekt bei jeder Sitzung neu zu erklären.

Schreibe sie einmal. Slate liest sie bei jedem relevanten Durchlauf.

Erstelle die Ordnerstruktur:

1mkdir -p .slate/skills/ci-triage
2touch .slate/skills/ci-triage/SKILL.md

Schreibe die Skill:

1---
2name: "ci-triage"
3description: "Klassifiziere CI-Fehler nach Ursache und entwirf Korrekturen für die einfachen."
4---
5
6# CI Triage Skill
7
8## Was ich tue
9Wenn ein CI-Lauf fehlschlägt, mache ich:
101. Lese die Testausgabe
112. Klassifiziere den Fehler: Umgebungsproblem / flaky Test / echter Bug / Abhängigkeitsproblem / Infra
123. Entwerfe Korrekturen für Bugs und Abhängigkeitsprobleme
134. Eskaliere Umgebungs- und Infra-Probleme an Menschen
14
15## Klassifikationsregeln
16- env: fehlendes Secret, falsche Umgebungsvariable → für Menschen markieren
17- flake: besteht beim erneuten Ausführen ohne Codeänderung → einmal wiederholen, dann Issue erstellen
18- bug: deterministischer Fehler, der mit einem aktuellen Commit zusammenhängt → Korrektur entwerfen
19- dependency: Fehler im Zusammenhang mit einem Versionssprung → Rollback-PR entwerfen
20- infra: Timeout, OOM, Runner-Problem → sofort eskalieren
21
22## Korrekturmuster
23- Auth-Testfehler → zuerst src/auth/middleware.ts prüfen
24- Datenbank-Testfehler → überprüfen, ob die Migration in der CI-Umgebung ausgeführt wurde
25- E2E-Fehler → UI-Selektoren gegen den letzten Snapshot prüfen
26
27## Niemals tun
28- Fehlschlagende Tests deaktivieren
29- CI-Konfiguration ohne Nachfrage ändern
30- src/billing/ oder src/payments/ anfassen
31
32## Zustand
33Aktualisiere STATE.md nach jedem Durchlauf:
34- Geprüfte Dateien
35- Getroffene Klassifikationen
36- Eröffnete PRs
37- Eskalierte Punkte

Liste verfügbare Skills in Slate auf:

1/skills

Aktiviere eine manuell:

1@ci-triage bitte triagiere die heutigen fehlschlagenden Tests

Oder Slate aktiviert Skills automatisch, wenn es entscheidet, dass sie für die aktuelle Aufgabe relevant sind.

Schritt 5 — Füge Zustand hinzu (das Gedächtnis des Loops)

Der Agent vergisst.

Die Datei nicht.

Erstelle STATE.md im Stammverzeichnis deines Projekts:

1# Loop-Zustand — CI Triage
2
3## Letzter Durchlauf
428.06.2026 03:30 UTC — 7 Fehler klassifiziert, 3 Korrekturen entworfen, 4 eskaliert
5
6## In Bearbeitung
7- claude/fix-auth-token-refresh — Tests bestehen lokal, warte auf CI
8- claude/fix-flaky-payment-webhook — Wiederholungsmuster angewendet, überwache
9
10## Abgeschlossen
11- claude/bump-axios-1.7.4 → gemerged (CI grün)
12- claude/lint-fix-pass-june-28 → gemerged
13
14## An Menschen eskaliert
15- src/billing/refund.ts — Tests schlagen auf 3 Arten fehl, Grundursache unklar
16- ci/staging-runner — Infra-Timeouts, kein Code-Problem
17
18## Gelernte Lektionen
19- 27.06.2026: PowerShell hat ein TLS 1.2-Problem auf diesem Windows-Runner. Bash verwenden.
20- 26.06.2026: tests/e2e/checkout benötigt Stripe-Webhook-Secret in der Umgebung. Überspringen, wenn nicht vorhanden.

Sage Slate, dass es dies zu Beginn jeder Sitzung verwenden soll, indem du es zu AGENTS.md hinzufügst:

1## Sitzungsbeginn
2Lies immer zuerst STATE.md. Setze dort fort, wo der letzte Durchlauf aufgehört hat.
3Aktualisiere STATE.md am Ende jedes Durchlaufs mit dem, was getan wurde und was als nächstes ansteht.

Ohne Zustand: Jeder Durchlauf beginnt bei Null.

Mit Zustand: Jeder Durchlauf setzt fort und baut auf dem letzten auf.

Schritt 6 — Baue den eigentlichen Loop

Jetzt hast du:

→ Arbeitsbereich eingerichtet (AGENTS.md)

→ Konfiguration gesetzt (slate.json)

→ Einen zuverlässigen manuellen Durchlauf nachgewiesen

→ Eine Skill geschrieben (ci-triage)

→ Zustandsdatei erstellt (STATE.md)

Zeit, es in einen echten Loop zu verpacken.

Option A: Warteschlangen-Datei-Loop (am einfachsten)

Erstelle loop.md:

1Lies STATE.md, um zu verstehen, was bereits versucht wurde.
2
3Führe die CI-Triage-Skill für alle fehlschlagenden Tests im letzten Build aus.
4
5Für jeden Fehler:
6- Klassifiziere ihn mit den Regeln der ci-triage-Skill
7- Entwirf eine Korrektur für Bugs und Abhängigkeitsprobleme
8- Eskaliere Umgebungs- und Infra-Probleme
9
10Führe die Korrekturen aus. Überprüfe, ob die Tests bestehen.
11Wenn Tests bestehen → PR eröffnen.
12Wenn Tests immer noch fehlschlagen → in STATE.md aufzeichnen und stoppen.
13
14Aktualisiere STATE.md mit allem, was in diesem Durchlauf getan wurde.
15
16Harter Stopp: maximal 8 Versuche. Bei Limit, aktuellen Zustand melden.

Führe es aus:

1slate --queue loop.md

Slate liest die Warteschlangendatei und führt jeden Block als Nachricht in der Warteschlange aus.

Option B: Headless/CI-Loop (automatisiert)

Führe nicht-interaktiv in einem GitHub Action oder Cron-Job aus:

1slate run "$(cat loop.md)" --output-format stream-json --dangerously-skip-permissions

In einem GitHub Actions-Workflow:

1name: CI Triage Loop
2on:
3  workflow_run:
4    workflows: ["CI"]
5    types: [completed]
6
7jobs:
8  triage:
9    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Slate installieren
15        run: npm i -g @randomlabs/slate
16
17      - name: Triage-Loop ausführen
18        env:
19          SLATE_API_KEY: ${{ secrets.SLATE_API_KEY }}
20        run: |
21          slate run "$(cat loop.md)" \
22            --output-format stream-json \
23            --dangerously-skip-permissions \
24            --workspace ./src \
25            --workspace ./tests

Jetzt löst jeder CI-Fehler automatisch den Triage-Loop aus.

Kein Mensch nötig, bis zur Eskalation.

Schritt 7 — Füge Subagenten hinzu (die Maker-Checker-Aufteilung)

Die mit Abstand wichtigste strukturelle Verbesserung für jeden Loop.

Lass niemals denselben Agenten seine eigenen Hausaufgaben benoten.

Das Modell, das die Korrektur geschrieben hat, ist ein zu großzügiger Benoter.

In Slate kannst du verschiedene Modelle für verschiedene Rollen festlegen:

1{
2  "models": {
3    "main": { "default": "anthropic/claude-opus-4.6" },
4    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
5    "search": { "default": "anthropic/claude-haiku-4.5" }
6  }
7}

Dann schreibe deine Aufgabe so, dass Slate diese Aufteilung natürlich nutzt:

1Bitte behebe die fehlschlagenden Auth-Tests.
2
3Schritt 1: Lass einen Suchagenten src/auth/ erkunden, um die aktuelle Implementierung zu verstehen.
4Schritt 2: Lass einen separaten Agenten die Korrektur basierend auf dem Gefundenen implementieren.
5Schritt 3: Lass einen dritten Agenten die Korrektur gegen die ursprünglichen Testanforderungen verifizieren —
6        dieser Agent sollte die Implementierung NICHT gesehen haben.
7Schritt 4: Öffne den PR nur, wenn der Verifizierer zustimmt.

Slate orchestriert die Subagenten automatisch.

Der Suchagent verwendet ein schnelles, günstiges Modell. Der Implementierungsagent verwendet ein stärkeres Modell. Der Verifizierer verwendet ein strenges Modell ohne Zugriff auf die Argumentation des Erstellers.

Diese Aufteilung ist der Grund, warum Slate 5 parallele Subagenten für eine einzige Aufgabe ausführen kann — jeder spezialisiert, jeder isoliert.

Schritt 8 — Das State-Loop-Muster (für langlaufende Aufgaben)

Für Aufgaben, die über Stunden oder Tage laufen, verwende dieses Muster in deinem Aufgaben-Prompt:

1Du führst einen Multi-Session-Loop aus.
2
3ZIEL: Migriere alle Express-Routen zum neuen ApiError-Muster.
4Verfolge den Fortschritt in STATE.md.
5
6BEGINN JEDER SITZUNG:
71. Lies STATE.md
82. Finde das erste unvollständige Element unter "Verbleibende Routen"
93. Bearbeite nur dieses Element
10
11ENDE JEDER SITZUNG:
121. Verschiebe abgeschlossene Elemente zu "Erledigte Routen" in STATE.md
132. Zeichne alle Blocker unter "Blocker" auf
143. Aktualisiere den Zeitstempel "Letzter Durchlauf"
154. Beende sauber
16
17STATE.md-Format:
18---
19## Erledigte Routen
20- [x] /api/users (27.06.2026)
21- [x] /api/auth/login (28.06.2026)
22
23## Verbleibende Routen
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## Blocker
29- /api/payments/refund — erfordert menschliche Überprüfung (betrifft Abrechnungslogik)
30
31## Letzter Durchlauf
3228.06.2026 14:30 UTC
33---
34
35HARTE REGELN:
36- Niemals src/billing/ ohne menschliche Genehmigung anfassen
37- Führe nach jeder Routenmigration immer Tests aus
38- Stoppe nach dem Abschluss EINER Route pro Sitzung

Führe dies jeden Morgen aus:

1slate --continue "$(cat loop.md)"

--continue setzt die letzte Sitzung fort, anstatt neu zu beginnen.

Jeden Tag eine weitere Route. STATE.md verfolgt alles.

Der Loop setzt genau dort fort, wo er aufgehört hat.

Schritt 9 — Benutzerdefinierte Befehle für deine am häufigsten verwendeten Loops

Füge benutzerdefinierte Slash-Befehle zu slate.json hinzu, damit deine Loops immer nur einen Tastendruck entfernt sind:

1{
2  "command": {
3    "triage": {
4      "description": "CI-Triage-Loop ausführen",
5      "template": "Lies STATE.md. Führe die ci-triage-Skill für alle fehlschlagenden Tests aus. Aktualisiere STATE.md, wenn fertig.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Eine Datei auf Korrektheit überprüfen",
10      "template": "Überprüfe @$ARGUMENTS auf Korrektheit, Randfälle und Konsistenz mit dem umgebenden Code."
11    },
12    "migrate": {
13      "description": "Eine Route zum ApiError-Muster migrieren",
14      "template": "Lies STATE.md. Migriere die nächste unvollständige Route zum ApiError-Muster. Führe Tests aus. Aktualisiere STATE.md."
15    }
16  }
17}

Jetzt in Slate:

1/triage
2/review src/api/payments.ts
3/migrate

Jeder führt sofort deinen vorgefertigten Loop-Prompt aus.

3 vollständige Loops, die du heute ausführen kannst

Loop 1: CI-Fehler-Triage (den wir gebaut haben)

Wann: bei jedem CI-Fehler Was: klassifizieren → einfache beheben → schwierige eskalieren → PRs eröffnen Zustand: STATE.md Tor: Tests bestehen Einrichtungszeit: 30 Minuten

1# Auslöser
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# oder in GitHub Actions — siehe Schritt 6 oben

Loop 2: Morgenbriefing

Wann: 7 Uhr jeden Werktag (Cron-Job) Was: letzte 24h Commits, PRs und offene Issues scannen → 5-Punkte-Briefing schreiben → in Slack posten

1# loop.md für Morgenbriefing
2cat > morning-brief-loop.md << 'EOF'
3Lies die letzten 24 Stunden von:
4- git log --since="24 hours ago" --oneline
5- Offene PRs im Entwurfs- oder Überprüfungsstatus
6- GitHub Issues, die in den letzten 24h erstellt oder aktualisiert wurden
7
8Schreibe ein Morgenbriefing:
9- 3 wichtigste Dinge, die passiert sind
10- 2 Dinge, die heute Aufmerksamkeit benötigen
11- 1 Sache, die jemanden blockieren könnte
12
13Halte es unter 120 Wörtern. Poste es in den #engineering-Slack-Channel.
14EOF
15
16# mit Cron planmäßig ausführen
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

Loop 3: Abhängigkeits-Upgrade-Loop

Wann: jeden Montag Was: nach veralteten Paketen suchen → Kompatibilität testen → PRs für sichere Upgrades eröffnen

1cat > deps-loop.md << 'EOF'
2Lies STATE.md.
3
4Führe aus: npm outdated
5
6Für jedes veraltete Paket:
71. Überprüfe, ob der Versionssprung major (breaking) oder minor/patch (sicher) ist
82. Für minor/patch: aktualisiere das Paket, führe npm test aus
93. Wenn Tests bestehen: eröffne einen PR
104. Wenn Tests fehlschlagen: zeichne in STATE.md als "benötigt menschliche Überprüfung" auf
115. Für major-Sprünge: immer an Menschen eskalieren
12
13Harte Regeln:
14- Niemals mehr als 5 Pakete in einem einzigen Loop aktualisieren
15- Niemals Pakete im Abschnitt "peer dependencies" aktualisieren
16- Führe nach jeder Aktualisierung immer die gesamte Testsuite aus, nicht nur verwandte Tests
17
18Aktualisiere STATE.md mit dem, was aktualisiert und was eskaliert wurde.
19EOF
20
21# jeden Montag ausführen
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

Die Fehlermodi, die Geld kosten

Kennt diese, bevor ihr etwas plant.

Der Ralph-Wiggum-Loop

Der Agent erklärt eine halbfertige Aufgabe für erledigt.

Bricht früh ab. Der Loop gibt weiter Geld aus. Lautlos.

Behebung: Harte Stoppbedingung, die von einem frischen Modell überprüft wird.

1STOPP-BEDINGUNG: Alle Tests in tests/auth/ bestehen UND lint gibt 0 zurück.
2Überprüfe mit einem separaten Prüfdurchlauf, nicht mit dem eigenen Urteil des Agenten.
3Hartes Limit: 8 Iterationen. Bei Limit: Zustand melden und stoppen.

Ziel-Abweichung

Bei langen Sitzungen verschwinden frühe Einschränkungen.

"Niemals src/billing/ anfassen" aus Nachricht 3 ist bei Nachricht 47 weg.

Behebung: Füge eine VISION.md hinzu, die Slate zu Beginn jeder Sitzung erneut liest.

1# VISION.md — Zu Beginn jeder Sitzung lesen
2
3## Kernziel
4Migriere alle Express-Routen zum ApiError-Muster.
5
6## Harte Einschränkungen (niemals verletzen)
7- Niemals src/billing/ ohne menschliche Genehmigung anfassen
8- Niemals fehlschlagende Tests deaktivieren
9- Vor dem Öffnen eines PRs immer die gesamte Testsuite ausführen
10
11## Aktuelle Priorität
12Routen in src/api/payments/ — mit besonderer Vorsicht behandeln

Selbstbevorzugungs-Bias

Der Ersteller benotet seine eigenen Hausaufgaben. Gibt sich immer eine Bestehensnote.

Behebung: Verifizierer-Subagent ohne Zugriff auf die Argumentation des Erstellers.

Sage Slate explizit:

1Der Verifizierer-Agent sollte die Arbeit des Implementierungsagenten NICHT sehen.
2Er sollte nur sehen: die ursprünglichen Testanforderungen und die Testausgabe.
3Wenn Tests bestehen → genehmigen. Wenn Tests fehlschlagen → ablehnen. Keine Meinung sonst.

Agentische Faulheit

Der Loop nennt eine Aufgabe bei teilweiser Erledigung "gut genug erledigt."

Besonders bei vagen Erfolgskriterien.

Behebung: Nur objektive Stoppbedingung.

1ERLEDIGT WENN: npm test Exit-Code 0 zurückgibt UND npm run lint Exit-Code 0 zurückgibt.
2Nicht wenn "Tests sehen gut aus." Nicht wenn "die meisten Tests bestehen."
3Exit-Code 0 bei beiden Befehlen. Das ist das einzige "erledigt."

Die Slate-spezifischen Tricks, die zählen

Ein paar Dinge, die Slate in der Praxis von anderen Agenten unterscheiden.

Nachrichten in die Warteschlange stellen, während es arbeitet

Slate führt eine lange Aufgabe aus. Dir fällt etwas Wichtiges ein.

Drücke Tab, um die Nachricht in die Warteschlange zu stellen — sie wird ausgeführt, nachdem die aktuelle Aufgabe beendet ist, ohne sie zu unterbrechen.

1[Slate arbeitet an der Migrationsaufgabe...]
2
3Du: Stell sicher, dass das neue Muster auch den Fall behandelt, wenn userId null ist
4[Tab — in Warteschlange gestellt]
5
6[Slate beendet den aktuellen Schritt, liest dann deine in die Warteschlange gestellte Nachricht]

Steuerung während des Laufs

Wenn Slate in die falsche Richtung geht, musst du es nicht stoppen:

1[Slate ist mitten in der Implementierung der Korrektur...]
2
3Du: Warte — füge dafür keine neue Klasse hinzu. Verwende das bestehende BaseError in src/utils/errors.ts
4[Enter — steuert sofort um]
5
6Slate: Verstanden, wechsle den Ansatz zur Verwendung von BaseError...

Verwende /enter-mode-next, um zwischen den Modi steuern / in Warteschlange stellen / unterbrechen zu wechseln.Shell-Befehle direkt

Führe Befehle innerhalb der Slate-Sitzung aus, ohne in ein anderes Terminal zu wechseln:

1!npm test          # Tests ausführen und Ausgabe an Slate senden
2!git diff HEAD     # prüfen, was sich geändert hat
3!git status        # aktuellen Zustand anzeigen

Slate liest die Ausgabe und verwendet sie für seine nächste Aktion.

Server-Modus für Team-Setups

Führe Slate als Server aus und verbinde dich von mehreren Terminals aus:

1# Terminal 1 — Server starten
2slate serve --port 7777
3
4# Terminal 2 — TUI anhängen
5slate attach http://localhost:7777 --dir /pfad/zum/projekt

Nützlich für Pair-Programming mit Slate oder zum Ausführen auf einem entfernten Rechner.

Die vollständige Einrichtungs-Checkliste

Bevor du deinen ersten echten Loop ausführst:

1□ npm i -g @randomlabs/slate installiert
2□ AGENTS.md mit Projektübersicht, Befehlen, Regeln erstellt
3□ slate.json mit Berechtigungen und Modellkonfiguration erstellt
4□ Ein manueller Durchlauf abgeschlossen und als zuverlässig verifiziert
5□ SKILL.md für deine erste wiederholte Aufgabe geschrieben
6□ STATE.md erstellt und in AGENTS.md referenziert
7□ loop.md mit expliziter Stoppbedingung geschrieben
8□ Hartes Limit für Iterationen (maximal 8 zum Start)
9□ Verifizierer ist NICHT derselbe Agent wie der Ersteller
10□ Menschliche Überprüfung für jede irreversible Aktion (PRs, Deployments)

Hake jedes Kästchen ab, bevor du etwas planst.

Überspringe eines, und der Loop scheitert entweder lautlos oder berechnet dir nichts.

Für weitere Loop-Inspiration

Sobald du das Muster verstanden hast, verschiebt sich der Engpass von „Wie baue ich einen Loop?" zu „Welchen Loop sollte ich als nächstes bauen?"

Die Forward Future Loop Library unter signals.forwardfuture.com/loop-library ist ein guter Ort, um echte, laufende Loops in verschiedenen Kategorien zu durchstöbern – Content, Engineering, Operations, Forschung.

Wenn du 20 funktionierende Loops an einem Ort siehst, hörst du auf, in einmaligen Prompts zu denken.

Die unbequeme Wahrheit

Zwei Entwickler können exakt denselben Loop ausführen und zu gegensätzlichen Ergebnissen kommen.

Der eine nutzt ihn, um bei Arbeit, die er bereits tiefgreifend versteht, schneller voranzukommen.

Der andere nutzt ihn, um das Verständnis der Arbeit gänzlich zu vermeiden.

Der Loop kennt den Unterschied nicht.

Du schon.

Loop-Design ist schwieriger als Prompt-Engineering – nicht einfacher.

Der Punkt ist nicht, dass die Arbeit leichter geworden ist.

Der Hebelpunkt hat sich verschoben.

Baue den Loop.

Aber baue ihn wie jemand, der vorhat, der Ingenieur zu bleiben.

Nicht nur die Person, die auf „Start" drückt.

Und das neue GPT-5.6 ersetzt dieses Prinzip nicht. Wenn überhaupt, verstärkt es es.

Die Grenze verläuft nicht mehr entlang der Frage, wer den cleversten Prompt schreibt.

Sondern darum, wer die besten Systeme rund um immer leistungsfähigere Modelle entwirft.

Die 60-Sekunden-Zusammenfassung

Was ein Loop ist:

→ Prompt = Frage. Loop = Job.

→ Entdecken → Ausführen → Verifizieren → Iterieren → Stoppen

Der 4-Bedingungen-Test:

→ Aufgabe wiederholt sich / Verifizierung automatisiert / Budget absorbiert Verschwendung / „Erledigt" ist objektiv

Die 5 Einrichtungsschritte:

→ AGENTS.md → slate.json → ein manueller Durchlauf → SKILL.md → STATE.md

Dann einpacken:

→ loop.md Warteschlangendatei ODER headless Slate-Durchlauf in CI

Die Fehlermodi:

→ Ralph Wiggum (bricht frühzeitig ab) / Ziel-Drift (vergisst Einschränkungen) / Selbstbevorzugungs-Bias (Macher = Prüfer) / Agentische Trägheit („gut genug")

Der Slate-Vorteil:

→ Automatische Modellauswahl pro Schritt → Parallele Sub-Agents mit Isolation → Langzeitsitzungsverwaltung → Dein Loop, dein Design

Falls das nützlich war:

→ Teile den Beitrag mit jedem Entwickler, den du kennst

→ Folge @sairahul1 für weitere Systeme wie dieses

→ Setze ein Lesezeichen – die Einrichtungs-Checkliste allein ist es wert, gespeichert zu werden

Abonniere theaibuilders.co für weitere interessante Artikel dieser Art

Ich schreibe über KI, Produktentwicklung und Systeme, die laufen, während du schläfst.

Erwähnte Tools:

→ Slate-Dokumentation: docs.randomlabs.ai

→ Forward Future Loop Library: signals.forwardfuture.com/loop-library