672 Stunden AI-Coding: Die härtesten Lektionen aus dem längsten KI-Entwicklungsexperiment

37 Stunden ununterbrochene KI-Arbeit. 250+ erledigte Tasks. Ein 2.000-Zeilen-Anforderungsdokument. Dan von der Morning Maker Show hat nach eigener Aussage Hunderte Stunden YouTube-Videos geschaut und unzählige Artikel gelesen, um einen funktionierenden Ralph-Loop-Workflow zusammenzustellen.

Das Ergebnis: Drei vollständige Projekte — und ein Open-Source-Paket (npx @pagei/offloop) das den gesamten Workflow reproduzierbar macht.

Der Ralph Loop — benannt nach Ralph Wiggum aus den Simpsons, geprägt von Geoffrey Huntley — ist konzeptionell simpel: Eine Endlosschleife die einen KI-Agenten immer wieder den gleichen Prompt ausführen lässt, bis alle Tasks erledigt sind. Jede Iteration startet mit frischem Kontext. Der State lebt in Dateien und Git, nicht im LLM-Memory.

Aber was auf dem Papier nach einer Bash-Zeile aussieht, ist in der Praxis ein komplexes System aus Requirements Engineering, Task-Dekomposition, Validierung und Fehlerbehandlung. Dan hat das in 672 Stunden Praxis gelernt — und diese Lektionen sind Gold wert.

Phase 1: Brain Dump → PRD

Man schreibt Anforderungen in eigenen Worten auf — unstrukturiert, unvollständig, in natürlicher Sprache. Ein Agent-Skill transformiert diesen rohen Input in ein professionelles Product Requirements Document (PRD). Dieses PRD wird zur "Source of Truth" für den gesamten Loop.

Warum das funktioniert: LLMs sind exzellent darin, unstrukturierte Anforderungen in strukturierte Dokumente zu übersetzen. Was sie schlecht können: Aus einem vagen PRD die richtigen Implementierungsentscheidungen ableiten. Deshalb muss das PRD detailliert sein — 2.000 Zeilen sind keine Seltenheit.

Phase 2: PRD → Tasks

Das PRD wird in kleine, handhabbare Tasks zerlegt. Jeder Task hat:

• Name und ID — eindeutig referenzierbar
• Metadaten — Abhängigkeiten, Priorität, geschätzte Komplexität
• Pass/Fail-Kriterien — automatisiert prüfbar (Tests, Linter, Build)
• Spec-Datei — detaillierte Implementierungsanweisungen in einer separaten Datei

Die Task-Liste (tasks.json) muss kompakt bleiben, weil sie bei jeder Iteration in den Kontext geladen wird. Jedes Byte zählt wenn das Context Window begrenzt ist.

Phase 3: Docker-Sandbox → Loop

Der Agent läuft in einem Docker-Container mit --dangerously-skip-permissions. Das ist nur sicher innerhalb der Sandbox. Der Loop arbeitet die Task-Liste sequenziell ab, commitet nach jeder erfolgreichen Task in Git, und startet die nächste Iteration mit frischem Kontext.

Wenn ein Task fehlschlägt, wird er zurückgesetzt und erneut versucht — bis zu einem konfigurierbaren Retry-Limit. Wenn das Limit erreicht ist, wird der Task als "blocked" markiert und der nächste beginnt.

1. "Die Dumb Zone vermeiden"

Nach einiger Zeit im Kontext vergisst das Modell frühe Teile der Konversation — ein Phänomen das als "Context Rot" oder "Context Degradation" bekannt ist. MIT-Forscher haben gezeigt, dass die Accuracy von LLMs bei langen Kontexten drastisch sinkt. Der Loop löst das elegant: Jede Iteration startet frisch. State wird in Textdateien und Git-Commits gehalten, nicht im LLM-Kontext.

2. Task-Review NICHT überspringen

Dan warnt ausdrücklich: "Der Drang alles abzunicken ist gross — aber wer nicht reviewt, erlebt nasty surprises." Jede Task-Liste muss manuell geprüft werden bevor der Loop startet. Tasks die zu gross, zu vage oder falsch priorisiert sind, führen zu Kaskadenfehlern die den gesamten Run ruinieren können.

3. Dokumentation einbinden — oder der Agent erfindet APIs

Für Drittanbieter-Services (Stripe, Auth0, Supabase) die Docs als Markdown speichern und im Prompt verlinken. Ohne das entsteht "Implementation Drift" — der Agent erfindet API-Endpoints die nicht existieren, weil sein Trainingswissen veraltet ist.

4. Bootstrap vor dem Loop

Die Codebasis manuell vorbereiten: Projektstruktur, Dependencies, Basis-Konfiguration, Test-Setup. Der Agent ist signifikant besser darin, bestehenden Code zu erweitern als von Null zu starten. Matt Pocock bestätigt das in seinem Ralph-Loop-Tutorial: "Der Agent braucht eine solide Basis um darauf aufzubauen."

5. Git als Sicherheitsnetz

Jeder erfolgreiche Task = ein Commit. Wenn Task N+1 den Code zerstört, reverted man zu Task N. Ohne Git ist ein 37-Stunden-Run ein Glücksspiel. Bei EconLab AI haben wir das zu einem Checkpoint-System erweitert: Automatische Git-Tags vor strukturellen Änderungen, mit Rollback-Capability über einen eigenen CLI-Befehl.

6. Spec-Dateien statt große Prompts

Statt einen riesigen Prompt zu schreiben, referenziert jeder Task eine separate Spec-Datei. Das hält den Kontext schlank und die Instruktionen präzise. Anthropic bestätigt in ihrer Forschung zu "Effective Harnesses for Long-Running Agents": Die Qualität der Ergebnisse korreliert direkt mit der Präzision der Task-Spezifikation, nicht mit der Laenge des Prompts.

7. Docker ist nicht optional

--dangerously-skip-permissions OHNE Docker = der Agent hat vollen Zugriff auf Ihr System. Dateien löschen, Prozesse killen, Netzwerkverkehr — alles möglich. Docker isoliert den Blast Radius auf den Container. Nono.sh bietet eine leichtgewichtige Alternative für macOS-Sandboxing auf OS-Level.

Dan hat den gesamten Workflow als Open-Source-Paket veröffentlicht: npx @pagei/offloop. Es automatisiert:

• PRD-Generierung aus Brain-Dump-Notizen
• Task-Dekomposition mit automatischer Spec-Datei-Erstellung
• Docker-Container-Setup mit vorkonfigurierter Sandbox
• Loop-Execution mit Git-Commits nach jedem Task
• Status-Reporting über die Task-Liste

Das Paket zeigt einen wichtigen Trend: Die Infrastruktur um KI-Agenten herum — das "Harness" — wird zum eigentlichen Differenzierungsmerkmal. Das Modell ist austauschbar. Der Harness entscheidet über Erfolg oder Scheitern.

Vergleichbare Tools: Matt Pococks Ralph-Setup, Karpathys Autoresearch Framework, Anthropics eigene Sandbox-Runtime. Alle basieren auf dem gleichen Prinzip: Frische Sessions, persistenter State, automatisierte Validierung.

Bei EconLab AI haben wir den Ralph Loop nicht einfach übernommen — wir haben ihn weiterentwickelt. Unser UltraLoop adressiert vier Schwächen des klassischen Ansatzes:

1. Persistentes Cross-Session-Wissen

Der klassische Ralph Loop startet jede Iteration bei Null. Das ist gut für Context Rot, aber schlecht für Lerneffekte. Unser UltraLoop speichert Erkenntnisse aus vorherigen Iterationen in strukturierten Dateien (claude-progress.txt, AGENTS.md) die bei jeder neuen Session geladen werden. Der Agent erinnert sich an Fehler und Lösungen — ohne unter Context Rot zu leiden.

2. Automatische Context-Rotation

Statt einer einfachen Bash-Schleife orchestriert der UltraLoop den Prompt-Aufbau dynamisch: Nur die relevanten Kontextdateien werden geladen, basierend auf dem aktuellen Task. Das reduziert den Context-Overhead von ~5.000 Tokens auf ~500 Tokens pro Session.

3. Checkpoint-basiertes Recovery

Nicht nur Git-Commits, sondern benannte Checkpoints mit Typ-Klassifizierung (FEAT, FIX, SAFE, MILE). Rollback auf einen spezifischen Checkpoint über CLI, nicht über Git-Log-Suche.

4. Audit-Trail

Jede Entscheidung des Agenten wird dokumentiert — welcher Task, welcher Prompt, welches Ergebnis, welche Fehler. Das ist nicht nur Best Practice, sondern mit dem EU AI Act (ab August 2026 relevant) auch zunehmend eine regulatorische Anforderung.

Metrik	Dan (Morning Maker)	EconLab UltraLoop
Längster Run	37 Stunden	Kontinuierlich (multi-day)
Tasks pro Run	250+	Variabel (project-abhängig)
Projekte ausgeliefert	3	30+ (seit 2025)
Basis-Workflow	Ralph Loop	UltraLoop (Ralph-Derivat)
Persistenz	Git + tasks.json	Git + Checkpoints + Progress-Files + AGENTS.md
Sandboxing	Docker	Docker + Nono.sh + Seatbelt
Agent-System	Claude Code (Single)	100+ spezialisierte Agents + 17 Skills
Audit-Trail	Git-History	Strukturierte Logs + Git + Checkpoint-Metadaten

Dans Experiment hat uns drei Dinge bestätigt: Der Ralph Loop funktioniert in der Praxis für echte Projekte. State-Management in Dateien schlägt State im Kontext. Docker-Sandboxing ist nicht verhandelbar — besonders für autonome Nacht-Läufe.

Was wir hinzugefügt haben: Persistentes Lernen, strukturierte Recovery, Audit-Fähigkeit und Multi-Agent-Orchestrierung. Der UltraLoop ist kein Gegenentwurf zum Ralph Loop — er ist seine natürliche Evolution für produktive Umgebungen.

Ob Sie Dans offloop-Paket nutzen, Matt Pococks Setup nachbauen, oder Ihren eigenen Loop entwickeln — die Kernprinzipien sind identisch:

1. Frische Sessions schlagen lange Sessions. Context Rot ist real. Starten Sie jede Iteration mit frischem Kontext.
2. State gehört in Dateien, nicht ins LLM. Git, JSON, Markdown — alles besser als LLM-Memory.
3. Validierung vor Iteration. Kein Task gilt als erledigt ohne automatisierte Prüfung (Tests, Build, Linter).
4. Sandboxing ist Pflicht. Docker, Nono.sh, oder OS-Level-Isolation. Kein autonomer Agent ohne Sandbox.
5. Das Harness ist wichtiger als das Modell. Claude Opus 4.6, GPT-5, Gemini 3 — alle gut genug. Der Unterschied liegt in der Infrastruktur drumherum.

672 Stunden AI-Coding haben gezeigt: Die Zukunft der Softwareentwicklung ist nicht "KI ersetzt Entwickler". Sie ist "Entwickler die KI-Systeme orchestrieren, produzieren 10x den Output". Und dafür braucht man keine 672 Stunden — man braucht den richtigen Loop.