Finalmente chegou o que vocês queriam! Ralph TUI, Ralph Loop Visualizado

Eu escrevi um tutorial sobre ralph-loop antes, e muitos amigos que o executaram deram um feedback consistente: É bom demais, o Claude Code finalmente consegue rodar por um longo tempo. Mas às vezes você observa e parece que ele não está se movendo, e você inevitavelmente se pergunta: "Ele está realmente avançando ou apenas girando em círculos?"

Essa é a razão pela qual eu estive mexendo com o ralph-tui recentemente.

Ralph TUI

O ralph-tui não força a vinculação ao Claude Code, ele herda e desenvolve a essência do ralph loop, e visualiza a execução e o processo das tarefas, reduzindo significativamente a barreira para que grandes modelos trabalhem por longos períodos. Você pode conectar outros agentes, outros modelos, nacionais, baratos, aqueles que você pode manter rodando por um longo tempo. Com o ralph-tui, para nós, pessoas comuns, o significado não é menor do que mudar de um carro manual para um automático com controle de cruzeiro.

O que diabos é isso?

Você pode entender o ralph-tui como um "orquestrador de loop de agentes de codificação de IA", só que ele não se contenta em "poder rodar", ele se preocupa mais com "você pode ver, pode controlar, pode recuperar".

Sua forma básica de trabalho é muito simples:

Você dá a ele um monte de tarefas (pode vir de um PRD, pode vir de outro sistema de tarefas)
Ele escolhe a de maior prioridade
Monta o prompt
Inicia o agente para executar
Julga se essa tarefa é considerada concluída
Grava o status
A próxima rodada continua

O ponto principal é: você pode ver tudo isso no terminal e pode parar e assumir o controle a qualquer momento. Oficialmente, eles também escreveram o posicionamento de forma muito direta: um orquestrador de loop de agente com TUI interativo, e suporta TUI / headless / remote.

Por que eu digo que é mais adequado para "rodar por um longo tempo"?

O maior problema de um script rodando em loop não é não conseguir rodar, mas sim você não saber onde ele está rodando.

Você vê os logs atualizando rapidamente, e o ventilador também está girando feliz, mas você não tem certeza:

Ele está repetidamente corrigindo o mesmo bug?
Ele está constantemente alterando o mesmo trecho de código e depois alterando de volta?
Ele já terminou, mas não saiu?
Ele está preso em um loop infinito em algum teste?

Interface TUI

A solução do ralph-tui é muito "engenharia":

Tem um conceito de sessão, o status será salvo em disco (.ralph-tui/session.json)
Pode ser recuperado após uma falha (crash recovery)
Tem um mecanismo de bloqueio para evitar que você abra várias instâncias e transforme o diretório em uma bagunça
Também pode ser executado headless no CI, e até mesmo abrir um listener remotamente e conectar o TUI localmente

Em uma frase: É mais como "você está gerenciando um trabalhador que sabe escrever código" do que "você está observando um script enlouquecendo".

Como instalar

O ralph-tui é um ecossistema Bun/TypeScript, então a instalação é bem tranquila. O site oficial também fornece uma página de instalação.

Primeiro, verifique se você tem o bun na sua máquina:

bun --version Em seguida, instale o ralph-tui (aqui eu dou um exemplo típico de instalação, consulte a página de instalação oficial para obter detalhes):

bun add -g ralph-tui Após a instalação, verifique:

ralph-tui --help Se você é um fã do Node e não quer mexer com o bun, também pode:

npm i -g ralph-tui

Não faça nada grandioso ainda, execute um loop mínimo

Eu sugiro que, na primeira vez que usar, não comece com algo como "reestruturar todo o repo". Faça apenas uma coisa: faça com que ele execute uma pequena tarefa aceitável.

Inicialização

Abre um diretório qualquer:

mkdir ralph-tui-demo && cd ralph-tui-demo ralph-tui setup Isso entrará no fluxo do assistente interativo, que basicamente é "instalar o ralph-tui neste seu repositório", ele irá:

Detecta automaticamente quais agentes você tem instalados em sua máquina (como Claude Code, OpenCode, etc.)
Gera um arquivo de configuração no projeto: .ralph-tui/config.toml
Instala as skills relacionadas à geração de PRD/conversão de tarefas (para que você não precise se preocupar em fazer isso manualmente depois)

Minha recomendação pessoal: não seja preguiçoso na primeira vez, execute o setup uma vez.

Gerar PRD do Projeto

Depois de executar o setup, o próximo passo é o mais importante do tutorial oficial e o mais adequado para escrever um artigo de demonstração: create-prd.

O comando ralph-tui create-prd --chat iniciará um fluxo de diálogo, onde ele irá questioná-lo sobre os objetivos, limites e critérios de aceitação dos requisitos, como um gerente de produto. Depois de perguntar, ele irá gerar duas coisas diretamente no projeto (este é o ponto principal):

Um arquivo markdown de PRD: ./tasks/prd-feature.md
Um arquivo de tarefa executável diretamente: ./prd.json

Neste ponto, você realmente entrou no "ciclo padrão" do ralph-tui:

Requisitos (PRD) → Tarefas (prd.json) → Execução (run)

Executar

Com o prd.json, executar torna-se natural:

ralph-tui run --prd ./prd.json Você verá a TUI iniciar e começar o loop: selecionar tarefa → executar → julgar como concluída → escrever o status → finalizar ou próxima rodada.

Na primeira vez que executar, sugiro fortemente adicionar um limite de iteração, para mantê-lo sob controle:

ralph-tui run --prd ./prd.json --iterations 5 Depois de executar, verifique as alterações, execute testes e veja se o PRD e as tarefas atendem às expectativas. Confirme se este caminho está funcionando antes de liberar as iterações e usar headless/remote, este é o ritmo certo.

Neste ponto, você pode basicamente confirmar: este loop realmente está funcionando.

Como escolher o Modelo/Agente? Economizar dinheiro requer honestidade

Eu sei que muitos estão mais preocupados com: "Posso não usar o Claude Code? Posso usar um modelo mais barato?"

A resposta é: Sim.

O ralph-tui em si suporta a especificação de um agente e modelo (há exemplos na documentação oficial do run).

Por exemplo, usando Claude Opus:

ralph-tui run --prd ./prd.json --agent claude --model opus Mas, honestamente, eu não usaria o Opus para fazer coisas como "adicionar testes, corrigir lint", é muito caro. Meu hábito é estratificar:

Modelos baratos: executam muito trabalho repetitivo (adicionar testes, adicionar comentários, corrigir formatação, adicionar limites)
Modelos caros: aparecem apenas em nós críticos (ajustes de arquitetura, bugs difíceis, lógica central)

Se você é um desenvolvedor comum, essa forma de pensar é ainda mais importante. Porque você não tem o orçamento de uma grande empresa, você precisa manter os custos sob controle para poder executar por mais tempo.

Quer algo ainda melhor? Deixe o agente "escrever o PRD"

O ralph-tui tem um design que eu gosto muito: ele suporta skills (basicamente um conjunto de comandos extras para o agente).

A maneira oficial de instalar é usando add-skill:

bunx add-skill subsy/ralph-tui --all Ou instale em um agente específico, como claude-code:

bunx add-skill subsy/ralph-tui -a claude-code -g -y Depois de instalar, você pode usar o comando slash na sessão do agente:

/ralph-tui-prd /ralph-tui-create-json /ralph-tui-create-beads É como se você tivesse instalado um plugin no IDE, só que este plugin é para o agente. O objetivo é reduzir o tempo de "transferência manual de requisitos", tornando os requisitos → tarefas → execução mais como uma linha de produção.

Quando devo usá-lo? Quando não devo usá-lo?Eu não gosto muito da narrativa de "tudo pode ser resolvido com IA", é fácil induzir ao erro. Uma ferramenta é apenas uma ferramenta, só vale a pena se for adequada para o cenário.

Cenários adequados para usar ralph-tui

Você tem um monte de tarefas como estas:

Complementar testes (especialmente em projetos antigos)
Corrigir lint / formatar
Refatoração em pequenos passos (convergir código repetido)
Adicionar tipos em lote, complementar limites
Desmembrar requisitos e avançar lentamente em uma fila de tarefas

Essas tarefas têm um ponto em comum: muitas tarefas, alta repetibilidade, podem ser validadas, podem ser promovidas iterativamente.

Cenários inadequados para forçar o uso de ralph-tui

Você está fazendo algo como isto:

Uma grande refatoração única, com critérios de aceitação pouco claros
O requisito em si é vago, dependendo do seu conhecimento implícito
Requer muita comunicação/confirmação entre equipes
Requer que você faça julgamentos de produto

Para essas tarefas, o agent loop só vai amplificar a confusão.

Qual a diferença entre ele e o ralph-loop (ralph-claude-code)?

ralph-claude-code é mais como um "plug-in de direção autônoma para Claude Code": o script o inicia, executa o loop, e a detecção de saída, limitação de taxa e disjuntor são todos cobertos para você. Se você quer "rapidez", ele é muito rápido.

ralph-tui é mais como um "console de controle de engenharia para agent loop": ele não solda um modelo específico, nem um sistema de tarefas específico. Ele quer resolver problemas de engenharia como "execução de longo prazo, observabilidade, controlabilidade, recuperabilidade, capacidade remota".

Então, você me pergunta como escolher?

Você é um usuário do Claude Code e quer executá-lo rapidamente → ralph-claude-code
Você quer conectar diferentes modelos, quer economizar dinheiro, quer gerenciar o loop como um serviço → ralph-tui

Por fim: não deixe que ele use seu repositório como um laboratório

Eu mesmo tenho algumas regras de ouro para executar agent loop, escrevo aqui para você seguir, a probabilidade de dar errado será muito menor:

Execute em um branch, não se mate no main.
Na primeira execução, sempre adicione --iterations, primeiro confirme em pequenos passos que ele não vai enlouquecer.
A tarefa deve ser validável: ou pode executar testes, ou pode executar lint, ou pode comparar arquivos de saída.
Você deve aprender a parar: vendo que ele está começando a dar voltas, pausar é mais inteligente do que continuar gastando dinheiro.
Modelos baratos fazem o trabalho bruto, modelos caros fazem o trabalho crítico: o custo é gerenciado, não rezado.Endereço do Projeto: https://github.com/subsy/ralph-tui