Ralph Wiggum Loop: 24/7 autonome Softwareentwicklung mit Spec-Kit Extension (2026)

Dario Amodei schreibt keinen Code mehr. OpenAI auch nicht. Fortune titelt: "100% of code is now AI-written". Gartner prognostiziert, dass 40% aller Enterprise-Apps bis Ende 2026 KI-Agenten integrieren. 92% der US-Entwickler nutzen taglich KI-Coding-Tools. Und auf LinkedIn ist jeder zweite Post eine Prediction daruber, wann Softwareentwickler uberflussig werden.

Das ist keine Zukunftsmusik. Das ist Februar 2026. Autonome Agenten können immer besser und besser komplexe Aufgaben erfolgreich bewältigen. Stundenlang und ohne Aufsicht.

Wir bei T-0 lassen seit Monaten KI-Agenten autonom an unseren Systemen arbeiten. Nicht nur als Experiment. Nicht als öde Demo. Sondern als Daily Driver für echte Operations. Die Loop Agenten scannen Issues, spezifizieren Anpassungen an der Architektur, liefern und committen Code, laufen Tests, deployen Features – auch nachts, auch am Wochenende. Nicht, weil wir keine Entwickler mehr brauchen. Sondern weil unsere Entwickler und Spezialisten jetzt Loop Engineers sind, die KI-Systeme orchestrieren statt Zeile fur Zeile zu schreiben.

Das Werkzeug dafur heisst Ralph Loop. Ab heute ist unser Beitrag dazu ebenfalls Open Source. Autonome Softwareentwicklung wie in Frontier Labls für jede*n mit Claude Code (und bald auch anderen Agent Harnesses).

Link zum Public Github Repository t-0-spec-kit-ralph:

github.com/T-0-co/t-0-spec-kit-ralph

WTF, what or who is Ralph?

Spec-Kit Ralph basiert auf Geoff Huntley's Original Ralph Wiggum Technik. Die Originalidee ist elegant simpel:

while :; do cat PROMPT.md | claude ; done

Ein Loop. Ein Prompt. Claude arbeitet, committed, Loop startet neu mit frischem Kontext. Huntley's Kernidee: Beobachte den Loop. Wenn du ein Failure Pattern siehst, löse das Problem so, dass es nie wieder auftritt. Du bist der Engineer des Loops, nicht der Entwickler des Features.

Ralph is an orchestrator pattern where you allocate the array with the required backing specifications and then give it a goal then looping the goal. It's important to watch the loop as that is where your personal development and learning will come from. When you see a failure domain – put on your engineering hat and resolve the problem so it never happens again.
— Geoff Huntley

Unsere Adaption baut darauf auf und integriert GitHub's Spec Kit Workflow: Statt einer generischen IMPLEMENTATION_PLAN.md arbeitet Ralph eine strukturierte tasks.md mit Phasen, parallelen Tasks und User Stories ab. Pro Task eine frische Claude Code Session. Kein Context Compaction. Kein Vergessen.

Das Problem, das Ralph löst

Spec-Driven Development mit Claude Code funktioniert. Der Flow ist klar:

/speckit.specify → /speckit.plan → /speckit.tasks → /speckit.implement

Der letzte Schritt ist das Problem. /speckit.implement läuft in einer einzelnen Claude Code Session. Bei 50 Tasks passiert das hier:

• Task 1-15: Läuft super. Claude hat vollen Kontext.
• Task 16-30: Context Compaction setzt ein. Claude vergisst Details aus der Spec, oder bestimmte Regeln einzuhalten.
• Task 31-50: Du steuerst manuell nach, copy-pastest Kontext rein, startest Sessions neu.
• Was passiert erst bei 500 Tasks?

Das Ergebnis: 30 bis 300 HITL-Interventionen pro komplexem Feature. Bei geschätzt 24 Stunden Arbeit mit AI Augmentation bis zu 20 Stunden mit dem Menschen im Loop (Iteration, Debug, Specs verfeinern, Refactor).

Die Zahlen nach Ralph

Mit Ralph als Orchestrator sieht das so aus:

10x Effizienz pro HITL-Stunde. Das ist nicht theoretisch. Das sind unsere tatsächlichen Werte aus laufenden Projekten. Die längere AI-Implementierungszeit ist dabei vor allem eine Frage der Loop-Optimierung und der verfügbaren Hardware. Auf einer 8GB-RAM-Maschine sind parallele Tests begrenzt. Mit mehr Ressourcen und stabilen Worktree-Setups wird das deutlich schneller.

Anders formuliert: Das Ding ist ein 24/7-Developer für ca. 6€/h (bei einer Claude Max x20 Subscription). Noch kein perfekter Developer. Aber einer, dem wir das gerade endgültig beibringen.

Wie Ralph funktioniert

┌──────────────────────────────────────────────────────────────┐
│ PHASE 1: Spec Kit (Interaktiv - du bist dabei)               │
│──────────────────────────────────────────────────────────────│
│ /speckit.specify  →  spec.md                                 │
│ /speckit.plan     →  plan.md, data-model.md                  │
│ /speckit.tasks    →  tasks.md (z.B. 50 Tasks in 5 Phasen)    │
├──────────────────────────────────────────────────────────────┤
│ PHASE 2: Ralph Loop (Headless - du gehst weg)                │
│──────────────────────────────────────────────────────────────│
│ $ ./speckit.ralph.extension specs/001-feature/               │
│                                                              │
│   Task T001 → Claude → build/test OK → commit                │
│   Task T002 → Claude → build/test OK → commit                │
│   Task T003 → Claude → build/test FAIL → retry → OK          │
│   ...                                                        │
│   Task T050 → Claude → build/test OK → DONE                  │
├──────────────────────────────────────────────────────────────┤
│ PHASE 3: Review (Du kommst zurück)                           │
│──────────────────────────────────────────────────────────────│
│ git log, progress.json, session.log checken                  │
│ Wenn geblockt: fixen, ./ralph --resume                       │
│ Wenn fertig: PR ready, alle Tests grün                       │
└──────────────────────────────────────────────────────────────┘

Jeder Task bekommt eine eigene Claude Code Session mit frischem Kontext. Ralph injiziert dabei:

• Die aktuelle Task-Beschreibung und Phase
• spec.md, plan.md, data-model.md (vollständig oder gekürzt)
• ralph-global.md mit Workspace-weiten Skill-Mappings
• ralph-spec.md (optional) mit Feature-spezifischen Anweisungen
• Die Liste bereits erledigter Tasks

Das Claude Code CLI wird so aufgerufen:

timeout 7200 claude --print --dangerously-skip-permissions -p "$prompt"

120 Minuten Timeout pro Task. Wenn der Build nach dem Task fehlschlägt, wird retried. Wenn nach 3 Versuchen (Default) nichts geht, blockiert Ralph und wartet auf menschliche Intervention. Graceful Stop jederzeit über eine .stop-Datei.

Was T-0 Ralph anders macht

Das Live Dashboard

Während Ralph läuft, zeigt ralph-context.sh in einem separaten Terminal den aktuellen Stand:

Progress, aktuelle Task-Dauer, Retry-Counter, durchschnittliche Task-Zeit, Git-Statistiken, Docker-Health, welche Skills gerade laufen. Alles auf einen Blick. In einem Warp Split-Tab neben der tmux-Session.

Loop Engineering: Die eigentliche Arbeit

Ralph installieren und laufen lassen ist der einfache Teil. Die eigentliche Arbeit ist sich klar zu werden was man eigentlich genau braucht und dann etwas neues: Loop Engineering - also den Loop so konfigurieren, dass er zuverlässig durchläuft.

Das bedeutet konkret:

• Skills bauen. Claude Code entdeckt Skills automatisch in .claude/skills/. Ein my-app-docker-server Skill, der zuverlässig die Dev-Server startet. Ein my-app-playwright-runner Skill, der E2E-Tests korrekt ausführt. Ralph mappt Tasks auf Skills über ralph-global.md.
• Tasks richtig schneiden. Zu große Tasks führen zu Timeouts. Zu kleine Tasks erzeugen unnötige Context-Switches. Der Sweet Spot liegt bei Tasks, die Claude in 2-10 Minuten lösen kann.
• Specs verfeinern. Wenn Ralph an einer Stelle wiederholt scheitert, ist meist die Spec unklar. Statt den Loop zu fixen, fixst du die Spec. Das ist der Huntley-Mindset: Löse das Problem so, dass es nie wieder auftritt.
• Permissions scopen. --dangerously-skip-permissions ist der schnelle Weg. Der bessere Weg: Claude Code Settings mit granularen allowedTools konfigurieren.

Das Ergebnis nach ein paar Iterationen: Ein Loop, der 80-100 Tasks am Stück durcharbeitet. Mit einer Success Rate von 95%+. Über Nacht. Während du schläfst.

Parallelisierung: Zwei Wege

Für mehr effizienz unterstützt Ralph bei T-0 Parallelisierung auf gleich zwei Ebenen:

Innerhalb eines Tasks (Subagents): Tasks mit [P] Marker werden wie beim gewöhnlichen /speckit.implement in Batches gruppiert. Ralph spawnt dann innerhalb seiner Claude Code Session parallele Subagents über das Task Tool. Gut für unabhängige UI-Fixes oder ähnliche isolierte Änderungen. Die Marker werden beim /speckit.tasks Step automatisch vom Specify Workflow vergeben.

## Phase 5: Theming Fixes

- [ ] T085 [P] Fix light mode for IconPickerField
- [ ] T086 [P] Fix light mode for URLField
- [ ] T087 [P] Fix light mode for CTAArrayField

Außerhalb von Tasks (Worktrees): Mehrere Ralph Loops laufen parallel auf verschiedenen Git Worktrees. Jeder Loop arbeitet an einem eigenen Feature auf einem eigenen Branch. Unabhängige Commits, unabhängige PRs. Mehrere Specs parallel. So kann theoretisch bei gutem Loop Engineering eine Github Issues Liste automatisch in Specs verwandelt und implementiert werden.

# Loop 1: Feature A (im Haupt-Repo)
./ralph specs/010-feature-a/

# Loop 2: Feature B (im Worktree)
./ralph --worktree --branch feature-b specs/012-feature-b/

Beide Ansätze lassen sich kombinieren. Die Kosten pro HITL-Stunde sinken dabei nochmal deutlich. Man sieht genau, warum es auf einmal eher darauf ankommt, sich genügend Loops für den Dauerbetrieb zu spezifizieren. Hat man ein paar stabile Loops abgeschlossen, kann man sich Skills aus den Learnings bauen und die nächsten Ralph-Sessions werden (noch) einfacher.

Was im Repo steckt

Das Open-Source Repo enthält alles, was du brauchst:

• Core Ralph Loop Engine (lib/): ralph.sh (Loop), context-builder.sh (Prompt-Assemblierung), task-parser.sh, progress-tracker.sh, cost-tracker.sh, build-detector.sh, worktree-manager.sh
• Claude Code Agents: long-task-coordinator (autonome Multi-Step-Orchestrierung), code-reviewer (Quality Gates in Loops), test-runner (Test-fokussierter Agent)
• Claude Code Skills: workspace-ralph-orchestrator (Loop-Kontrolle aus dem Editor), skill-creator (neue projekt-spezifische Skills bauen)
• Installer: Symlink-Mode für Development, Copy-Mode für Standalone, optional mit upstream Spec Kit Assets

# Installation
git clone https://github.com/T-0-co/t-0-spec-kit-ralph.git
cd your-project
./path/to/speckit-ralph/install.sh --symlink

# Laufen lassen
./speckit.ralph.extension specs/001-feature/

Spec Kit ist empfohlen, aber kein Hard Requirement. Ralph arbeitet mit jeder tasks.md, die dem dokumentierten Format folgt.

Addon: autonomous-longtask-v2 (Session Management für lange Loops, sinnvoll um die aktuellsten Fähigkeiten nativer Claude Code Loops mit Ralph Loops zu vergleichen. Basiert auf den Empfehlungen von Anthropic. Einfach vor /speckit.implement injecten und Spec-Treue, Geschwindigkeit usw. mit der von Ralph Loops vergleichen).

Was noch kommt

Ralph ist experimental. Wir nutzen es produktiv, aber es gibt offene Fragen:

• Issue-Feed-Loop: Derzeit ist der Workflow Issue → Spec → Implement noch nicht im Repo-Package. Wir validieren gerade einen geschlossenen Loop, bei dem GitHub Issues automatisch priorisiert, an Ralph Worker delegiert und nach Review gemerged werden. Die Skills dafür existieren bereits. Offensichtlich wird das aber Anpassungen je nach Repo in dem der Ralph Loop eingesetzt wird bedürfen.
• Harness-Optimierung: Auch die richtige Balance zwischen Timeout, Retries und Task-Größe ist projektspezifisch. Wir lernen noch.
• Codex CLI Support: Ralph ist aktuell auf Claude Code optimiert. Support für andere Harnesses (Codex CLI, Gemini CLI, Qwen Code) ist geplant.
• Kosten-Tracking: Bei Claude Code Subscriptions (lokale Runs) ist das Token-Tracking derzeit inaktiv, für API-Use funktioniert es.

Unsere Prediction: In einem Jahr liegt die durchschnittliche Zeit pro gelöstem Issue unter 5 Minuten. Das klingt aggressiv. Aber wenn du dir anschaust, wie schnell sich Loop Engineering entwickelt, ist es realistisch. Wir setzen die Loops inzwischen auch schon erfolgreich dafür ein, PRs aus einer Vielzahl parallel entwickelter Worktrees zu mergen.

Probier es aus

Das Repo ist live: github.com/T-0-co/t-0-spec-kit-ralph

Du brauchst: Claude Code, bash, git, jq. Optional: tmux für Background-Sessions. Alle Details im Repo. Auch eine einfache Installation via Claude Code ist möglich. Gib ihm einfach den Link zum Repo und lass es Ralph für dich in deinen Workspace oder in ein Repo einbauen.

Wenn du damit ein Projekt automatisierst und dabei auf Patterns stößt, die allgemein nützlich sind: PRs sind willkommen. Projekt-spezifische Logik bleibt bitte in deinem Repo.

Und wenn du dabei helfen willst, wie wir Loop Engineering in komplexen Setups implementieren: Schreib uns.

Willst du erfahren, wie Ralph Loops und andere angewandte KI-Systeme in digitalisierten Unternehmen produktiv werden:

Alle Entwickler ohne Ralph Loops gerade:

Weiterführend

• Geoff Huntley: The Ralph Wiggum Technique
• GitHub Spec Kit
• The Ralph Playbook (Clayton Farr)
• Anthropic: Claude Code Best Practices
• Geoff Huntley: Ralph Wiggum Loop (Video)
• Ralph Loop Deep Dive (Video)

Agentische KI für produktive Systeme mit dem Menschen im Zentrum · Made in Germany von T-0