Finalment ha arribat el que volíeu! Ralph TUI, Ralph Loop visualitzat

Abans vaig escriure un tutorial sobre ralph-loop, i molts amics que l'han executat han donat una resposta força consistent: És genial, Claude Code finalment pot executar-se durant molt de temps. Però de vegades l'observeu i sembla que no es mou, i inevitablement us pregunteu: "Està avançant o girant al mateix lloc?"

Aquesta és la raó per la qual he estat experimentant amb ralph-tui recentment.

ralph-tui no obliga a utilitzar Claude Code, hereta i desenvolupa l'essència de ralph loop, i visualitza l'execució de tasques i el procés, reduint considerablement el llindar per fer que els models grans treballin durant molt de temps. Podeu connectar-hi altres agents, altres models, models nacionals, barats, que pugueu executar a llarg termini. Amb ralph-tui, per a la gent normal com nosaltres, el significat no és menor que passar d'un canvi manual a un canvi automàtic amb control de creuer.

Què és exactament?

Podeu entendre ralph-tui com un "orquestrador de bucles d'agent de codificació d'IA", només que no es conforma amb "poder executar-se", sinó que està més interessat en "que pugueu veure, controlar i restaurar".

La seva forma bàsica de treballar és molt senzilla:

• Li doneu un munt de tasques (pot venir de PRD, o d'altres sistemes de tasques)
• Tria la de màxima prioritat
• Construeix el prompt
• Inicia l'agent per executar-la
• Jutja si la tasca es considera completada
• Escriu l'estat
• Continua a la següent ronda

El punt clau és: podeu veure tot això al terminal i podeu aturar-lo i fer-vos càrrec en qualsevol moment. Oficialment, també han escrit la seva posició de manera molt directa: un orquestrador de bucles d'agent amb TUI interactiu, i que admet TUI / headless / remote.

Per què dic que és més adequat per a "executar-se a llarg termini"?

El problema més gran d'executar un bucle amb un script no és que no es pugui executar, sinó que no sabeu on s'està executant.

Veieu que els registres s'actualitzen ràpidament, i el ventilador també gira feliçment, però no esteu segurs:

• Està reparant repetidament el mateix error?
• Està modificant repetidament el mateix codi i després tornant-lo a modificar?
• Ja s'ha completat, però no ha sortit?
• Està encallat en una prova en un bucle infinit?

La solució de ralph-tui és molt "d'enginyeria":

• Té un concepte de sessió, l'estat es desa al disc (.ralph-tui/session.json)
• Es pot restaurar l'execució en cas de fallada (crash recovery)
• Té un mecanisme de bloqueig per evitar que obriu diverses instàncies i convertiu el directori en un desastre
• També es pot executar headless a CI, i fins i tot remote obrir un listener a l'extrem remot i connectar-hi el TUI local

En una frase: És més com "estar gestionant un treballador que sap escriure codi", en lloc de "estar observant un script que es torna boig".

Com instal·lar-lo

El conjunt de ralph-tui és un ecosistema Bun/TypeScript, així que la instal·lació és força senzilla. L'oficial també ha proporcionat una pàgina d'instal·lació.

Primer, confirmeu que teniu bun a la vostra màquina:

bun --version

Després instal·leu ralph-tui (aquí us dono una instal·lació típica, consulteu la pàgina d'instal·lació oficial per a més detalls):

bun add -g ralph-tui

Després de la instal·lació, confirmeu-ho:

ralph-tui --help

Si sou un fan de Node i no voleu tocar bun, també podeu:

npm i -g ralph-tui

No feu res gran encara, executeu un bucle tancat mínim

Us recomano que la primera vegada que l'utilitzeu, no feu res com "reestructurar tot el repo". Només feu una cosa: feu que s'executi una petita tasca acceptable.

Inicialització

Obriu un directori qualsevol:

mkdir ralph-tui-demo && cd ralph-tui-demo ralph-tui setup

Això entrarà en un flux de guia interactiu, que bàsicament és "instal·lar ralph-tui al vostre repositori", farà:

• Detecta automàticament quins agents tens instal·lats a la teva màquina (per exemple, Claude Code, OpenCode, etc.)
• Genera un fitxer de configuració al projecte: .ralph-tui/config.toml
• Instal·la les skills relacionades amb la generació de PRD/conversió de tasques (així no t'hauràs de preocupar de fer-ho manualment després)

El meu consell personal: no siguis gandul la primera vegada, executa el setup una vegada sense falta.

Generar el PRD del projecte

Un cop executat el setup, el següent pas és el més important del tutorial oficial, i també el més adequat per escriure una demo per a un blog: create-prd.

L'ordre ralph-tui create-prd --chat iniciarà un procés de conversa, on et preguntarà com un product manager sobre els objectius, les condicions de contorn i els criteris d'acceptació de les teves necessitats. Un cop fet això, generarà dues coses directament al projecte (això és el més important):

• Un fitxer markdown de PRD: ./tasks/prd-feature.md
• Un fitxer de tasques executable directament: ./prd.json

En aquest punt, realment entres al "cicle estàndard" de ralph-tui:

Necessitat (PRD) → Tasca (prd.json) → Execució (run)

Executar-ho

Un cop tens el prd.json, executar-ho és lògic:

ralph-tui run --prd ./prd.json veuràs que s'inicia la TUI i comença el bucle: triar tasca → executar → jutjar si està completada → escriure l'estat → finalitzar o següent ronda.

La primera vegada que l'executis, recomano afegir un límit d'iteracions, per tancar-lo en una gàbia:

ralph-tui run --prd ./prd.json --iterations 5 Un cop executat, revisa els canvis, executa les proves, mira si el PRD i les tasques compleixen les expectatives. Confirma que aquesta cadena funciona, després allibera les iteracions i passa a headless/remote, aquest és el ritme adequat.

En aquest punt, bàsicament pots confirmar: aquest bucle realment funciona.

Com triar el model/Agent? Cal ser honest sobre estalviar diners

Sé que el que més preocupa a molta gent és: "Puc no utilitzar Claude Code? Puc utilitzar un model més barat?"

La resposta és: sí.

ralph-tui et permet especificar l'agent i el model (hi ha exemples a la documentació oficial de run).

Per exemple, utilitzant Claude Opus:

ralph-tui run --prd ./prd.json --agent claude --model opus Però sincerament, jo no utilitzaria Opus per fer coses com "afegir proves, arreglar lint", és massa car. El meu hàbit és estratificar:

• Models barats: executar molta feina repetitiva (afegir proves, afegir comentaris, arreglar format, afegir límits)
• Models cars: només apareixen en nodes clau (ajust d'arquitectura, errors difícils, lògica central)

Si ets un desenvolupador normal, aquesta manera de pensar és encara més important. Perquè no tens el pressupost d'una gran empresa, has de fer que el cost sigui controlable per poder executar-ho durant més temps.

Vols que sigui encara més fàcil? Delega també la "redacció del PRD" a l'agent

ralph-tui té un disseny que m'agrada molt: admet skills (que bàsicament són un conjunt d'ordres externes per a l'agent).

La manera oficial d'instal·lar-les és amb add-skill:

bunx add-skill subsy/ralph-tui --all O instal·lar-les a un agent específic, per exemple claude-code:

bunx add-skill subsy/ralph-tui -a claude-code -g -y Un cop instal·lades, pots utilitzar slash commands a la sessió de l'agent:

/ralph-tui-prd /ralph-tui-create-json /ralph-tui-create-beads Això és com si haguessis instal·lat un plugin a l'IDE, però aquest plugin és per a l'agent. La seva importància és reduir el temps de "trasllat manual de necessitats", fent que la necessitat → tasca → execució s'assembli més a una cadena de muntatge.

Quan hauries d'utilitzar-lo? Quan no?

No m'agrada gaire la narrativa de "tot es pot fer amb IA", és fàcil induir a error. Una eina és una eina, només val la pena en l'escenari adequat.

Escenaris adequats per a ralph-tui

Tens un munt de feina com aquesta:

• Complementar proves (especialment projectes antics)
• Corregir lint / format
• Refactorització en petits passos (convergir codi repetit)
• Afegir tipus per lots, complementar límits
• Descomposició de requisits i avançar lentament per la cua de tasques

Aquesta mena de feina té un punt en comú: moltes tasques, alta repetició, verificable, es pot avançar iterativament.

Escenaris inadequats per forçar ralph-tui

El que vols fer és això:

• Gran refactorització única, criteris d'acceptació poc clars
• El requisit en si és ambigu, depèn del teu coneixement implícit
• Cal molta comunicació/confirmació entre equips
• Cal que facis judicis sobre el producte

En aquesta mena de tasques, el bucle d'agent només amplificarà el caos.

Quina diferència hi ha entre ralph-tui i ralph-loop (ralph-claude-code)?

ralph-claude-code és més com un "complement de conducció autònoma per a Claude Code": l'script l'engega, executa el bucle i s'encarrega de la detecció de sortida, la limitació de velocitat i l'interruptor automàtic. El que vols és "ràpid", i és molt ràpid.

ralph-tui és més com una "consola de control d'enginyeria per al bucle d'agent": no està soldat a un model concret ni a un sistema de tasques concret. El que vol resoldre són problemes d'enginyeria com "execució a llarg termini, observable, controlable, recuperable, remot".

Llavors, em preguntes com triar?

• Ets usuari de Claude Code i vols que s'executi ràpidament → ralph-claude-code
• Vols connectar diferents models, vols estalviar diners, vols gestionar el bucle com un servei → ralph-tui

Finalment: no deixis que converteixi el teu repositori en un laboratori

Jo mateix tinc algunes regles d'or per executar el bucle d'agent, les escric aquí perquè les segueixis i la probabilitat de fracàs serà molt menor:

• Executa-ho en una branca, no juguis amb foc a la branca main.
• La primera vegada que l'executis, afegeix --iterations, primer confirma en petits passos que no es tornarà boig.
• La tasca ha de ser verificable: ja sigui que pugui executar proves, ja sigui que pugui executar lint, ja sigui que pugui comparar fitxers de sortida.
• Has d'aprendre a aturar-te: quan vegis que comença a donar voltes, és més intel·ligent aturar-se que seguir gastant diners.
• Models barats per a feina bruta, models cars per a feina crítica: el cost s'opera, no es resa.Adreça del projecte: https://github.com/subsy/ralph-tui