Endlich ist es da, was ihr wolltet! Ralph TUI, Visualisierung von Ralph Loop

Ich habe zuvor ein Tutorial über ralph-loop geschrieben, und viele Freunde haben nach dem Ausführen ein einheitliches Feedback gegeben: Es ist cool, Claude Code kann endlich lange laufen. Aber manchmal beobachtet man, dass es sich scheinbar nicht bewegt, und man fragt sich unweigerlich: "Geht es wirklich voran oder dreht es sich im Kreis?"

Das ist der Grund, warum ich mich in letzter Zeit mit ralph-tui beschäftigt habe.

ralph-tui erzwingt keine Bindung an Claude Code, sondern erbt und entwickelt die Essenz von ralph loop weiter und visualisiert die Aufgabenausführung und den Prozess, wodurch die Hürde für die langfristige Arbeit großer Modelle erheblich gesenkt wird. Du kannst problemlos andere Agents und andere Modelle anschließen, einheimische, billige, die du dir langfristig leisten kannst. Mit ralph-tui ist das für uns Normalsterbliche so, als würden wir von einem Schaltgetriebe auf ein Automatikgetriebe mit Tempomat umsteigen.

Was ist das eigentlich?

Du kannst dir ralph-tui als einen "zyklischen Orchestrator für KI-Coding-Agents" vorstellen, der sich aber nicht mit dem "Laufen können" zufrieden gibt, sondern mehr Wert darauf legt, dass "du es sehen, kontrollieren und wiederherstellen kannst".

Seine grundlegende Arbeitsweise ist sehr einfach:

• Du gibst ihm einen Haufen Aufgaben (entweder aus einem PRD oder aus einem anderen Aufgabensystem)
• Er wählt die Aufgabe mit der höchsten Priorität aus
• Erstellt einen Prompt
• Startet den Agent zur Ausführung
• Beurteilt, ob die Aufgabe als erledigt gilt
• Schreibt den Status
• Nächste Runde geht weiter

Wichtig ist: All das kannst du im Terminal sehen und jederzeit stoppen und übernehmen. Offiziell wird es auch ganz offen als ein Agent Loop Orchestrator mit interaktivem TUI positioniert, der TUI / headless / remote unterstützt.

Warum sage ich, dass es besser für "langfristiges Laufen" geeignet ist?

Das größte Problem beim Ausführen von Schleifen mit Skripten ist nicht, dass sie nicht laufen, sondern dass man nicht weiß, wo sie sich befinden.

Du siehst, wie die Protokolle schnell durchlaufen und der Lüfter sich auch fröhlich dreht, aber du bist dir nicht sicher:

• Wiederholt es immer wieder denselben Fehler?
• Ändert es immer wieder denselben Code und ändert ihn dann wieder zurück?
• Ist es schon fertig, beendet aber nicht?
• Steckt es in einem Test in einer Endlosschleife fest?

Die Lösung von ralph-tui ist sehr "ingenieurmäßig":

• Es gibt ein Session-Konzept, der Status wird auf die Festplatte geschrieben (.ralph-tui/session.json)
• Es kann nach einem Absturz wiederhergestellt werden (crash recovery)
• Es gibt einen Sperrmechanismus, um zu verhindern, dass du mehrere Instanzen öffnest und das Verzeichnis durcheinander bringst
• Es kann sogar headless in CI ausgeführt werden oder remote einen Listener öffnen, mit dem sich das lokale TUI verbinden kann

Mit einem Satz: Es ist eher so, als würdest du "einen Arbeiter verwalten, der Code schreiben kann", als "einem Skript beim Ausflippen zusehen".

Wie man es installiert

ralph-tui ist ein Bun/TypeScript-Ökosystem, die Installation ist also recht einfach. Die offizielle Seite bietet auch eine Installationsanleitung.

Stelle zunächst sicher, dass du Bun auf deinem Rechner hast:

bun --versionInstalliere dann ralph-tui (ich gebe hier eine typische Installation an, die genauen Angaben findest du auf der offiziellen Installationsseite):

bun add -g ralph-tuiÜberprüfe nach der Installation:

ralph-tui --helpWenn du ein Node-Anhänger bist und Bun nicht anfassen möchtest, geht das auch:

npm i -g ralph-tui

Fangt nicht gleich mit großen Dingen an, sondern führt einen minimalen geschlossenen Kreislauf aus

Ich empfehle, dass du beim ersten Mal nicht gleich etwas wie "das gesamte Repo umstrukturieren" machst. Mache nur eines: Sorge dafür, dass eine kleine, akzeptable Aufgabe erfolgreich ausgeführt wird.

Initialisierung

Öffne einfach ein Verzeichnis:

mkdir ralph-tui-demo && cd ralph-tui-demo ralph-tui setupDies führt dich durch einen interaktiven Assistenten, der im Grunde bedeutet, dass "ralph-tui in deinem Repository installiert wird". Er wird:

• Automatische Erkennung, welche Agents auf Ihrem Rechner installiert sind (z.B. Claude Code, OpenCode usw.)
• Erstellung einer Konfigurationsdatei im Projekt: .ralph-tui/config.toml
• Direkte Installation von Skills für die PRD-Generierung/Aufgabenkonvertierung (Sie müssen sich später nicht mehr selbst darum kümmern)

Meine persönliche Empfehlung: Seien Sie beim ersten Mal nicht faul, setup muss unbedingt einmal durchlaufen werden.

Generierung eines Projekt-PRD

Nach dem Durchlaufen von setup ist der nächste Schritt der wichtigste Teil des offiziellen Tutorials, der sich auch am besten für eine Demo in einem öffentlichen Konto eignet: create-prd.

Der Befehl ralph-tui create-prd --chat startet einen dialogorientierten Prozess, der Sie wie ein Produktmanager nach Ihren Zielen, Randbedingungen und Akzeptanzkriterien fragt. Nach der Befragung werden zwei Dinge direkt im Projekt ausgegeben (das ist der springende Punkt):

• Eine PRD-Markdown-Datei: ./tasks/prd-feature.md
• Eine direkt ausführbare Aufgabendatei: ./prd.json

An diesem Punkt betreten Sie erst wirklich den "Standard-Closed-Loop" von ralph-tui:

Anforderung (PRD) → Aufgabe (prd.json) → Ausführung (run)

Starten

Mit prd.json ist das Ausführen nur noch eine Formsache:

ralph-tui run --prd ./prd.json Sie sehen, dass die TUI startet und eine Schleife beginnt: Aufgabe auswählen → Ausführen → Abschluss beurteilen → Status schreiben → Beenden oder nächste Runde.

Beim ersten Ausführen empfehle ich dringend, ein Iterationslimit hinzuzufügen, um es zuerst in einen Käfig zu sperren:

ralph-tui run --prd ./prd.json --iterations 5 Nach dem Ausführen überprüfen Sie die Änderungen, führen Tests durch und prüfen, ob das PRD und die Aufgaben den Erwartungen entsprechen. Sobald Sie bestätigt haben, dass diese Kette funktioniert, können Sie die Iterationen freigeben und auf Headless/Remote umsteigen. Das ist der richtige Weg.

An diesem Punkt können Sie im Wesentlichen bestätigen: Diese Schleife läuft wirklich.

Wie wählt man Modell/Agent aus? Ehrlichkeit beim Sparen

Ich weiß, dass viele Leute sich am meisten darum sorgen: "Kann ich Claude Code nicht verwenden? Kann ich ein billigeres Modell verwenden?"

Die Antwort ist: Ja.

ralph-tui selbst unterstützt die Angabe von Agent und Modell (Beispiele finden Sie in der offiziellen Run-Dokumentation).

Zum Beispiel mit Claude Opus:

ralph-tui run --prd ./prd.json --agent claude --model opus Aber ehrlich gesagt würde ich Opus nicht für Aufgaben wie "Tests ergänzen, Lint beheben" verwenden, das ist zu teuer. Meine Gewohnheit ist die Schichtung:

• Billige Modelle: Führen Sie viele sich wiederholende Arbeiten aus (Tests ergänzen, Kommentare ergänzen, Formatierung korrigieren, Grenzen hinzufügen)
• Teure Modelle: Nur an wichtigen Knotenpunkten einsetzen (Architekturanpassung, schwierige Bugs, Kernlogik)

Wenn Sie ein normaler Entwickler sind, ist dieser Ansatz noch wichtiger. Da Sie kein großes Budget haben, müssen Sie die Kosten kontrollieren, um lange durchzuhalten.

Möchten Sie es noch angenehmer haben? Überlassen Sie die "PRD-Erstellung" auch dem Agenten

ralph-tui hat ein Design, das mir sehr gut gefällt: Es unterstützt Skills (im Grunde eine Reihe von Agent-Erweiterungsbefehlen).

Die offizielle Installationsmethode ist add-skill:

bunx add-skill subsy/ralph-tui --all Oder installieren Sie es auf einem bestimmten Agenten, z. B. claude-code:

bunx add-skill subsy/ralph-tui -a claude-code -g -y Nach der Installation können Sie Slash-Befehle in der Agent-Sitzung verwenden:

/ralph-tui-prd /ralph-tui-create-json /ralph-tui-create-beads Das ist so, als hätten Sie ein Plugin in Ihrer IDE installiert, nur dass dieses Plugin für den Agenten bestimmt ist. Es reduziert die Zeit für das "manuelle Verschieben von Anforderungen" und macht Anforderung → Aufgabe → Ausführung eher zu einer Fließbandarbeit.

Wann sollte man es verwenden? Wann nicht?Ich mag diese Erzählung "Alles kann mit KI erledigt werden" nicht besonders, sie ist leicht irreführend. Ein Werkzeug ist ein Werkzeug, es ist nur in der passenden Situation wertvoll.

Geeignete Szenarien für die Verwendung von ralph-tui

Du hast eine Menge solcher Aufgaben:

• Tests ergänzen (besonders bei alten Projekten)
• Lint / Formatierung reparieren
• Kleine Refactorings (doppelten Code zusammenführen)
• Massenhaft Typen hinzufügen, Grenzen ergänzen
• Anforderungen nach Aufgaben aufteilen und langsam vorantreiben

Diese Art von Arbeit hat einen gemeinsamen Nenner: Viele Aufgaben, hoher Wiederholungsgrad, abnehmbar, iterativ vorantreibbar.

Szenarien, in denen es nicht sinnvoll ist, ralph-tui zwanghaft einzusetzen

Du musst Folgendes tun:

• Einmaliges großes Refactoring, unklare Abnahmekriterien
• Die Anforderung selbst ist vage und basiert auf deinem impliziten Wissen
• Erfordert viel teamübergreifende Kommunikation/Bestätigung
• Erfordert, dass du Produktentscheidungen triffst

Bei solchen Aufgaben wird der Agent Loop nur das Chaos verstärken.

Worin besteht der Unterschied zu ralph-loop (ralph-claude-code)?

ralph-claude-code ist eher wie ein "Autopilot-Plugin für Claude Code": Das Skript startet es, führt die Schleife aus, Ausstiegserkennung, Ratenbegrenzung und Schutzschalter sind alle abgedeckt. Du willst "schnell", und es ist schnell.

ralph-tui ist eher wie eine "Engineering-Konsole für den Agent Loop": Es ist weder an ein bestimmtes Modell noch an ein bestimmtes Aufgabensystem gebunden. Es möchte die Engineering-Probleme "langfristiger Betrieb, Beobachtbarkeit, Kontrollierbarkeit, Wiederherstellbarkeit, Fernbedienung" lösen.

Also fragst du mich, wie du wählen sollst?

• Du bist ein Claude Code-Benutzer und möchtest es schnell zum Laufen bringen → ralph-claude-code
• Du möchtest verschiedene Modelle anschließen, Geld sparen und den Loop als Dienst verwalten → ralph-tui

Abschließend: Lass es dein Repository nicht als Labor missbrauchen

Ich selbst habe ein paar eiserne Regeln für das Ausführen von Agent Loops, die du befolgen solltest, um die Wahrscheinlichkeit eines Unfalls zu verringern:

• Auf einem Branch ausführen, nicht auf dem Main-Branch herumspielen.
• Beim ersten Ausführen unbedingt --iterations hinzufügen, um in kleinen Schritten zu bestätigen, dass es nicht verrückt spielt.
• Die Aufgabe muss abnehmbar sein: Entweder können Tests ausgeführt werden, oder Lint, oder Ausgabedateien verglichen werden.
• Du musst lernen, anzuhalten: Wenn du siehst, dass es sich im Kreis dreht, ist es klüger, anzuhalten, als weiter Geld zu verbrennen.
• Billige Modelle für grobe Arbeiten, teure Modelle für kritische Arbeiten: Kosten werden durch den Betrieb erzeugt, nicht durch Gebete.Projektadresse: https://github.com/subsy/ralph-tui