🧪 Loops para copiar e rodar

Aqui está o loop mais limpo que existe para começar: consertar testes que falham. O "pronto" é à prova de opinião — ou os testes passam, ou não. O prompt abaixo está completo: abra um projeto pequeno com algum teste quebrado e cole.

Objetivo: deixar o Claude Code rodar sozinho, em loop, até toda a suíte passar — fazendo uma correção por vez e parando no teto de tentativas.

# Cole no Claude Code dentro de um projeto com testes falhando

Objetivo: faça todo teste em /tests passar ao rodar `npm test`.

Loop:
  (1) rode `npm test` e leia as falhas;
  (2) abra o arquivo mais responsável pela 1ª falha e faça UMA correção;
  (3) rode `npm test` de novo pra verificar;
  (4) se ainda falhar, repita do passo 1.

Depois de cada correção que melhora, escreva 1 linha em PROGRESS.md e commite.
Pare quando todos passarem ou após 10 tentativas.
Não edite nada fora de /src e /tests, e não apague testes pra fazê-los passar.

Como verificar: assista o terminal — você deve ver o ciclo rodar testes → editar 1 arquivo → rodar de novo se repetindo, com o número de falhas caindo. No fim, rode npm test você mesmo e confira o verde; abra o PROGRESS.md e o git log para ver o rastro de cada volta.

Loop não é coisa de programador. A mesma forma serve para texto. Trocamos só o trabalho e o jeito de checar: o objetivo vira "reescrever este parágrafo", e o "pronto" vira duas regras objetivas que dá para contar.

Objetivo: encurtar um parágrafo até passar em duas regras mensuráveis, iterando sozinho até bater (ou parar em 5 tentativas).

# Cole no Claude Code (ou em qualquer chat com ferramentas de contagem)

Objetivo: reescreva o parágrafo abaixo.

Pronto quando: o texto está abaixo de 50 palavras E menciona a palavra "preço".

Loop:
  (1) reescreva uma versão;
  (2) conte as palavras e procure "preço";
  (3) se quebrar alguma regra, reescreva de novo mirando o que faltou;
  (4) repita.

Pare quando as duas regras passarem, ou após 5 tentativas.

Parágrafo:
<parágrafo que você cola aqui>

Como verificar: peça a contagem final de palavras (deve ser < 50) e procure "preço" no resultado. Repare: o check confere as regras, não se o texto ficou agradável de ler — isso é exatamente um check Functional. Se quiser elegância também, você adicionaria um segundo avaliador (tópico 6).

Em vez de escrever o loop à mão toda vez, você pode declarar o objetivo e deixar o Claude Code montar o ciclo. /goal diz onde chegar; /loop faz girar até lá. Juntos viram um loop que se auto-dirige e sabe a hora de parar.

Objetivo: gerar e refinar conceitos de thumbnail até um deles atingir a nota-alvo numa rubrica que você mesmo define.

# Cole no Claude Code

/goal Gerar 10 conceitos de thumbnail para um vídeo sobre <seu tema>.
      Pontue cada conceito de 0 a 10 em três critérios:
        - clareza (dá pra entender o tema em 1 segundo)
        - contraste (cores e formas saltam num feed)
        - curiosidade (dá vontade de clicar)
      A nota do conceito é a média dos três.
      Pronto quando o melhor conceito atingir nota média >= <8>.

/loop A cada volta: pegue o conceito de maior nota, descreva 2 variações
      dele mirando o critério mais fraco, pontue as variações pela mesma
      rubrica e mantenha a melhor. Pare quando bater a nota-alvo ou após
      8 voltas. Mostre a tabela de notas no fim.

Como verificar: no fim deve aparecer uma tabela com cada conceito e suas três notas, e o vencedor com média ≥ 8 (ou um aviso de que parou no teto sem bater). Confira você se a rubrica foi aplicada de forma consistente — se duas thumbnails parecidas tiraram notas muito diferentes, aperte a descrição dos critérios.

Quando o loop pode tocar em algo que dói desfazer — apagar arquivos, enviar e-mail, fazer um pagamento — você não quer que ele decida sozinho. Adicione um gate humano: uma linha que obriga o agente a parar e pedir sua confirmação antes de qualquer ação irreversível.

Objetivo: rodar um loop normalmente, mas com um freio que impede qualquer ação destrutiva ou externa sem sua aprovação explícita.

# Acrescente esta linha a QUALQUER prompt de loop deste módulo

Pause e me pergunte antes de deletar, enviar ou pagar qualquer coisa.

# (opcional, deixa o gate mais explícito)
Trate como irreversível: apagar/sobrescrever arquivos fora de /src,
fazer git push, enviar e-mail/mensagem, ou qualquer pagamento.
Nesses casos, descreva o que faria e espere meu "ok" antes de agir.

Como verificar: rode o loop sobre uma tarefa que naturalmente chega numa ação arriscada (ex.: limpar uma pasta). O agente deve parar e perguntar em vez de executar — se ele apagar algo sem te consultar, o gate não pegou: torne a lista de ações irreversíveis mais específica e teste de novo num diretório de brinquedo.

Tarefas grandes não cabem numa única passada. A solução é dar ao loop um lugar para guardar o estado: um arquivo de progresso que ele lê no começo e atualiza no fim de cada volta, mais um commit por mudança. Assim, se a sessão acabar, a próxima retoma de onde parou.

Objetivo: rodar um loop longo que progride uma feature por vez, salvando estado a cada volta para poder ser interrompido e retomado sem perder trabalho.

# Cole no Claude Code num repositório git

Objetivo: implementar <a feature/lista de tarefas> até estar completa e testada.

No início de cada volta:
  - leia PROGRESS.md para saber o que já foi feito e o que vem a seguir.

Durante a volta:
  - escolha a PRÓXIMA tarefa não-feita e trabalhe SÓ nela (uma de cada vez);
  - rode os testes para verificar a mudança (self-verify);
  - se passou: atualize PROGRESS.md (marque a tarefa, anote 1 linha do que fez)
    e faça um commit com uma mensagem curta e clara;
  - deixe a árvore de trabalho limpa (sem arquivos soltos) para a próxima volta.

Pare quando PROGRESS.md não tiver mais tarefas, ou após 15 voltas.

Como verificar: abra o PROGRESS.md e veja o histórico crescendo linha a linha; rode git log --oneline e confira um commit por mudança. O teste de fogo: interrompa o loop no meio, comece uma sessão nova com o mesmo prompt e veja se ele retoma da tarefa certa em vez de recomeçar do zero.

Todos os prompts deste módulo são o mesmo esqueleto com peças trocadas. Para a SUA tarefa, mantenha a forma do loop e troque só duas coisas: o domínio (que trabalho) e o checker (como medir "pronto").

O que ver: o fluxo é sempre copiar → colar → rodar → observar. O que muda de tarefa para tarefa não é a mecânica, são os campos <entre setas>: o objetivo, o que conta como pronto e o teto.

Os três tipos de checker que você vai trocar conforme a tarefa:

Objetivo: ter um template em branco para preencher com a sua tarefa — só troque os campos marcados <assim> e cole.

# Template em branco — preencha os campos <entre setas> e cole no Claude Code

Objetivo: <o que produzir, numa frase>.
Pronto quando: <o critério checável de "pronto">.

Loop:
  (1) faça UMA mudança em direção ao objetivo;
  (2) rode o check: <como medir — testes / contar / screenshot / 2º agente>;
  (3) se não passou, ajuste mirando o que faltou;
  (4) repita.

Salve o progresso: <ex.: 1 linha em PROGRESS.md + commit a cada melhora>.
Pare quando passar, ou após <N> tentativas.
Não toque em <o que está fora de escopo>; pause e me pergunte antes de
qualquer ação irreversível.

Como verificar: se você conseguiu preencher os quatro campos sem hesitar — objetivo, critério de pronto, qual checker, e o teto — sua tarefa está pronta para virar loop. Se travou no "Pronto quando", o problema não é o prompt: é que a tarefa ainda não tem um "pronto" checável (volte ao módulo 3.1, passo 2).