loops-autônomos

Habilidade de Loops Autônomos

Nota de compatibilidade (v1.8.0): autonomous-loops é mantido por um lançamento. O nome canônico da habilidade agora é continuous-agent-loop. Novas orientações de loop devem ser criadas lá, enquanto esta habilidade permanece disponível para evitar quebrar fluxos de trabalho existentes.

Padrões, arquiteturas e implementações de referência para executar o Claude Code de forma autônoma em loops. Abrange desde pipelines simples com claude -p até orquestração DAG multiagente completa orientada por RFC.

Quando Usar

• Configurar fluxos de trabalho de desenvolvimento autônomos que são executados sem intervenção humana
• Escolher a arquitetura de loop certa para o seu problema (simples vs complexo)
• Construir pipelines de desenvolvimento contínuo estilo CI/CD
• Executar agentes paralelos com coordenação de mesclagem
• Implementar persistência de contexto entre iterações de loop
• Adicionar portões de qualidade e passagens de limpeza a fluxos de trabalho autônomos

Espectro de Padrões de Loop

Do mais simples ao mais sofisticado:

Padrão	Complexidade	Melhor Para
Pipeline Sequencial	Baixa	Etapas diárias de desenvolvimento, fluxos de trabalho com script
NanoClaw REPL	Baixa	Sessões persistentes interativas
Loop Agentic Infinito	Média	Geração paralela de conteúdo, trabalho orientado por especificações
Loop Contínuo de PR do Claude	Média	Projetos iterativos de vários dias com portões de CI
Padrão De-Sloppify	Complemento	Limpeza de qualidade após qualquer etapa de Implementador
Ralphinho / DAG Orientado por RFC	Alta	Grandes funcionalidades, trabalho paralelo multiunidade com fila de mesclagem

---

1. Pipeline Sequencial (claude -p)

O loop mais simples. Divida o desenvolvimento diário em uma sequência de chamadas não interativas claude -p. Cada chamada é uma etapa focada com um prompt claro.

Insight Principal

Se você não consegue criar um loop como este, significa que você não consegue nem fazer o LLM corrigir seu código no modo interativo.

A flag claude -p executa o Claude Code de forma não interativa com um prompt e sai quando termina. Encadeie chamadas para construir um pipeline:

#!/bin/bash
# daily-dev.sh — Pipeline sequencial para uma branch de funcionalidade

set -e

# Etapa 1: Implementar a funcionalidade
claude -p "Leia a especificação em docs/auth-spec.md. Implemente o login OAuth2 em src/auth/. Escreva testes primeiro (TDD). NÃO crie nenhum novo arquivo de documentação."

# Etapa 2: De-sloppify (passagem de limpeza)
claude -p "Revise todos os arquivos alterados pelo commit anterior. Remova quaisquer testes de tipo desnecessários, verificações excessivamente defensivas ou testes de recursos de linguagem (por exemplo, testar que genéricos do TypeScript funcionam). Mantenha testes de lógica de negócios reais. Execute a suíte de testes após a limpeza."

# Etapa 3: Verificar
claude -p "Execute a compilação completa, lint, verificação de tipos e suíte de testes. Corrija quaisquer falhas. Não adicione novos recursos."

# Etapa 4: Commitar
claude -p "Crie um commit convencional para todas as alterações preparadas. Use 'feat: adicionar fluxo de login OAuth2' como mensagem."

Princípios Chave de Design

1. Cada etapa é isolada — Uma janela de contexto nova por chamada claude -p significa que não há vazamento de contexto entre etapas.
2. A ordem importa — As etapas executam sequencialmente. Cada uma se baseia no estado do sistema de arquivos deixado pela anterior.
3. Instruções negativas são perigosas — Não diga "não teste sistemas de tipos". Em vez disso, adicione uma etapa de limpeza separada (veja Padrão De-Sloppify).
4. Códigos de saída se propagam — set -e interrompe o pipeline em caso de falha.

Variações

Com roteamento de modelo:

# Pesquisa com Opus (raciocínio profundo)
claude -p --model opus "Analise a arquitetura do código e escreva um plano para adicionar cache..."

# Implementar com Sonnet (rápido, capaz)
claude -p "Implemente a camada de cache de acordo com o plano em docs/caching-plan.md..."

# Revisar com Opus (minucioso)
claude -p --model opus "Revise todas as alterações em busca de problemas de segurança, condições de corrida e casos extremos..."

Com contexto de ambiente:

# Passe contexto via arquivos, não pelo comprimento do prompt
echo "Áreas de foco: módulo de autenticação, limitação de taxa da API" > .claude-context.md
claude -p "Leia .claude-context.md para prioridades. Trabalhe nelas em ordem."
rm .claude-context.md

Com restrições --allowedTools:

# Passagem de análise somente leitura
claude -p --allowedTools "Read,Grep,Glob" "Audite este código em busca de vulnerabilidades de segurança..."

# Passagem de implementação somente gravação
claude -p --allowedTools "Read,Write,Edit,Bash" "Implemente as correções de security-audit.md..."

---

2. NanoClaw REPL

Loop persistente embutido do ECC. Um REPL com reconhecimento de sessão que chama claude -p de forma síncrona com histórico completo de conversa.

# Iniciar a sessão padrão
node scripts/claw.js

# Sessão nomeada com contexto de habilidade
CLAW_SESSION=my-project CLAW_SKILLS=tdd-workflow,security-review node scripts/claw.js

Como Funciona

1. Carrega o histórico de conversas de ~/.claude/claw/{session}.md
2. Cada mensagem do usuário é enviada para claude -p com o histórico completo como contexto
3. As respostas são anexadas ao arquivo de sessão (Markdown como banco de dados)
4. As sessões persistem entre reinicializações

Quando NanoClaw vs Pipeline Sequencial

Caso de Uso	NanoClaw	Pipeline Sequencial
Exploração interativa	Sim	Não
Automação com script	Não	Sim
Persistência de sessão	Embutida	Manual
Acumulação de contexto	Cresce por turno	Novo a cada etapa
Integração CI/CD	Ruim	Excelente

Consulte a documentação do comando /claw para detalhes completos.

---

3. Loop Agentic Infinito

Um sistema de dois prompts que orquestra subagentes paralelos para geração orientada por especificações. Desenvolvido por disler (crédito: @disler).

Arquitetura: Sistema de Dois Prompts

PROMPT 1 (Orquestrador)              PROMPT 2 (Subagentes)
┌─────────────────────┐             ┌──────────────────────┐
│ Analisar arquivo de   │             │ Receber contexto completo│
│ especificação         │  implanta   │ Ler número atribuído    │
│ Escanear diretório de │────────────│ Seguir especificação    │
│ saída                 │  N agentes  │ exatamente              │
│ Planejar iteração     │             │ Gerar saída única       │
│ Atribuir direções     │             │ Salvar no diretório de  │
│ criativas             │             │ saída                   │
│ Gerenciar ondas       │             │                         │
└─────────────────────┘             └──────────────────────┘

O Padrão

1. Análise da Especificação — O orquestrador lê um arquivo de especificação (Markdown) que define o que gerar
2. Reconhecimento de Diretório — Escaneia a saída existente para encontrar o maior número de iteração
3. Implantação Paralela — Lança N subagentes, cada um com:
   • A especificação completa
   • Uma direção criativa única
   • Um número de iteração específico (sem conflitos)
   • Um instantâneo das iterações existentes (para exclusividade)
4. Gerenciamento de Ondas — Para o modo infinito, implanta ondas de 3-5 agentes até que o contexto se esgote

Implementação via Comandos do Claude Code

Crie .claude/commands/infinite.md:

Analise os seguintes argumentos de $ARGUMENTS:
1. spec_file — caminho para o markdown de especificação
2. output_dir — onde as iterações são salvas
3. count — inteiro 1-N ou "infinite"

FASE 1: Leia e entenda profundamente a especificação.
FASE 2: Liste output_dir, encontre o maior número de iteração. Comece em N+1.
FASE 3: Planeje direções criativas — cada agente recebe um tema/abordagem DIFERENTE.
FASE 4: Implante subagentes em paralelo (ferramenta Task). Cada um recebe:
  - Texto completo da especificação
  - Instantâneo do diretório atual
  - Seu número de iteração atribuído
  - Sua direção criativa única
FASE 5 (modo infinito): Loop em ondas de 3-5 até que o contexto esteja baixo.

Invocar:

/project:infinite specs/component-spec.md src/ 5
/project:infinite specs/component-spec.md src/ infinite

Estratégia de Lotes

Contagem	Estratégia
1-5	Todos os agentes simultaneamente
6-20	Lotes de 5
infinito	Ondas de 3-5, sofisticação progressiva

Insight Chave: Exclusividade por Atribuição

Não confie que os agentes se diferenciarão sozinhos. O orquestrador atribui a cada agente uma direção criativa específica e um número de iteração. Isso impede conceitos duplicados entre agentes paralelos.

---

4. Loop Contínuo de PR do Claude

Um script shell de nível de produção que executa o Claude Code em um loop contínuo, criando PRs, aguardando CI e mesclando automaticamente. Criado por AnandChowdhary (crédito: @AnandChowdhary).

Loop Principal

┌─────────────────────────────────────────────────────┐
│  ITERAÇÃO CONTÍNUA DO CLAUDE                        │
│                                                     │
│  1. Criar branch (continuous-claude/iteration-N)   │
│  2. Executar claude -p com prompt aprimorado        │
│  3. (Opcional) Passagem de revisor — claude -p separado│
│  4. Commitar alterações (claude gera mensagem)      │
│  5. Enviar + criar PR (gh pr create)                │
│  6. Aguardar verificações de CI (poll gh pr checks) │
│  7. Falha de CI? → Passagem de correção automática (claude -p)│
│  8. Mesclar PR (squash/merge/rebase)                │
│  9. Retornar ao main → repetir                      │
│                                                     │
│  Limitar por: --max-runs N | --max-cost $X          │
│            --max-duration 2h | sinal de conclusão   │
└─────────────────────────────────────────────────────┘

Instalação

Aviso: Instale continuous-claude a partir de seu repositório após revisar o código. Não canalize scripts externos diretamente para o bash.

Uso

# Básico: 10 iterações
continuous-claude --prompt "Adicionar testes unitários para todas as funções não testadas" --max-runs 10

# Limitado por custo
continuous-claude --prompt "Corrigir todos os erros de linter" --max-cost 5.00

# Com limite de tempo
continuous-claude --prompt "Melhorar cobertura de testes" --max-duration 8h

# Com passagem de revisão de código
continuous-claude \
  --prompt "Adicionar recurso de autenticação" \
  --max-runs 10 \
  --review-prompt "Executar npm test && npm run lint, corrigir quaisquer falhas"

# Paralelo via worktrees
continuous-claude --prompt "Adicionar testes" --max-runs 5 --worktree tests-worker &
continuous-claude --prompt "Refatorar código" --max-runs 5 --worktree refactor-worker &
wait

Contexto Entre Iterações: SHARED_TASK_NOTES.md

A inovação crítica: um arquivo SHARED_TASK_NOTES.md persiste entre iterações:

## Progresso
- [x] Testes adicionados para módulo de autenticação (iteração 1)
- [x] Caso extremo corrigido na renovação de token (iteração 2)
- [ ] Ainda precisa: testes de limitação de taxa, testes de limites de erro

## Próximos Passos
- Focar no módulo de limitação de taxa em seguida
- A configuração de mock em tests/helpers.ts pode ser reutilizada

Claude lê este arquivo no início da iteração e o atualiza no final da iteração. Isso preenche a lacuna de contexto entre invocações independentes de claude -p.

Recuperação de Falha de CI

Quando as verificações de PR falham, o Continuous Claude automaticamente:

1. Busca o ID da execução com falha via gh run list
2. Gera um novo claude -p com contexto de correção de CI
3. Claude inspeciona logs via gh run view, corrige código, commita, envia
4. Re-aguarda verificações (até --ci-retry-max tentativas)

Sinal de Conclusão

Claude pode sinalizar "terminei" emitindo uma frase mágica:

continuous-claude \
  --prompt "Corrigir todos os bugs no rastreador de problemas" \
  --completion-signal "CONTINUOUS_CLAUDE_PROJECT_COMPLETE" \
  --completion-threshold 3  # Para após 3 sinais consecutivos

Três iterações consecutivas sinalizando conclusão interrompem o loop, evitando execuções desperdiçadas em trabalho concluído.

Configuração Chave

Flag	Propósito
--max-runs N	Parar após N iterações bem-sucedidas
--max-cost $X	Parar após gastar $X
--max-duration 2h	Parar após tempo decorrido
--merge-strategy squash	squash, merge, ou rebase
--worktree <name>	Execução paralela via git worktrees
--disable-commits	Modo de simulação (sem operações git)
--review-prompt "..."	Adicionar passagem de revisor por iteração
--ci-retry-max N	Corrigir automaticamente falhas de CI (padrão: 1)

---

5. O Padrão De-Sloppify

Um padrão complementar para qualquer loop. Adicione uma etapa dedicada de limpeza/refatoração após cada etapa do Implementador.

O Problema

Quando você pede a um LLM para implementar com TDD, ele leva "escrever testes" muito ao pé da letra:

• Testes que verificam o funcionamento do sistema de tipos do TypeScript (testando typeof x === 'string')
• Verificações defensivas excessivas em tempo de execução para coisas que o sistema de tipos já garante
• Testes para comportamento do framework em vez de lógica de negócios
• Tratamento excessivo de erros que obscurece o código real

Por Que Não Instruções Negativas?

Adicionar "não teste sistemas de tipos" ou "não adicione verificações desnecessárias" ao prompt do Implementador tem efeitos colaterais:

• O modelo se torna hesitante em relação a TODOS os testes
• Ele pula testes de caso extremo legítimos
• A qualidade degrada de forma imprevisível

A Solução: Passagem Separada

Em vez de restringir o Implementador, deixe-o ser minucioso. Em seguida, adicione um agente de limpeza focado:

# Etapa 1: Implementar (deixe ser minucioso)
claude -p "Implemente a funcionalidade com TDD completo. Seja minucioso com os testes."

# Etapa 2: De-sloppify (contexto separado, limpeza focada)
claude -p "Revise todas as alterações na árvore de trabalho. Remova:
- Testes que verificam comportamento de linguagem/framework em vez de lógica de negócios
- Verificações de tipo redundantes que o sistema de tipos já impõe
- Tratamento de erro excessivamente defensivo para estados impossíveis
- Instruções console.log
- Código comentado

Mantenha todos os testes de lógica de negócios. Execute a suíte de testes após a limpeza para garantir que nada quebre."

Em um Contexto de Loop

for feature in "${features[@]}"; do
  # Implementar
  claude -p "Implemente $feature com TDD."

  # De-sloppify
  claude -p "Passagem de limpeza: revise alterações, remova slop de teste/código, execute testes."

  # Verificar
  claude -p "Execute compilação + lint + testes. Corrija quaisquer falhas."

  # Commitar
  claude -p "Commite com mensagem: feat: adicionar $feature"
done

Insight Principal

Em vez de adicionar instruções negativas que têm efeitos colaterais na qualidade, adicione uma passagem de de-sloppify separada. Dois agentes focados superam um agente restrito.

---

6. Ralphinho / DAG Orientado por RFC

O padrão mais sofisticado. Um pipeline multiagente orientado por RFC

…

[truncado para tradução]