loops-autonomos

Skill de Loops Autônomos

Nota de compatibilidade (v1.8.0): autonomous-loops é mantido por uma versão. O nome canônico da skill agora é continuous-agent-loop. Novas orientações sobre loops devem ser escritas lá, enquanto esta skill permanece disponível para não quebrar fluxos de trabalho existentes.

Padrões, arquiteturas e implementações de referência para executar Claude Code autonomamente 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 rodam sem intervenção humana
• Escolher a arquitetura de loop correta para seu problema (simples vs complexo)
• Construir pipelines de desenvolvimento contínuo no estilo CI/CD
• Executar agentes paralelos com coordenação de merge
• Implementar persistência de contexto entre iterações do loop
• Adicionar verificações de qualidade e passes 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
REPL NanoClaw	Baixa	Sessões persistentes interativas
Loop Agêntico Infinito	Média	Geração de conteúdo paralela, trabalho orientado por especificação
Loop Contínuo de PR do Claude	Média	Projetos iterativos de vários dias com gates de CI
Padrão De-Sloppify	Complemento	Limpeza de qualidade após qualquer etapa de Implementador
Ralphinho / DAG Orientado por RFC	Alta	Funcionalidades grandes, trabalho paralelo multiunidade com fila de merge

---

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 Central

Se você não conseguir criar um loop como este, significa que você não consegue nem mesmo 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 login OAuth2 em src/auth/. Escreva testes primeiro (TDD). NÃO crie nenhum novo arquivo de documentação."

# Etapa 2: Desemburrecer (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 funcionalidades da linguagem (por exemplo, testar que generics do TypeScript funcionam). Mantenha testes de lógica de negócio reais. Execute o conjunto de testes após a limpeza."

# Etapa 3: Verificar
claude -p "Execute o build completo, lint, verificação de tipos e conjunto de testes. Corrija quaisquer falhas. Não adicione novas funcionalidades."

# 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. 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 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 tamanho 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 escrita
claude -p --allowedTools "Read,Write,Edit,Bash" "Implemente as correções de security-audit.md..."

---

2. REPL NanoClaw

Loop persistente embutido do ECC. Um REPL com consciência 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 skill
CLAW_SESSION=my-project CLAW_SKILLS=tdd-workflow,security-review node scripts/claw.js

Como Funciona

1. Carrega o histórico de conversa 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
Acúmulo 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 Agêntico Infinito

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

Arquitetura: Sistema de Dois Prompts

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

O Padrão

1. Análise da Especificação — O Orquestrador lê um arquivo de especificação (Markdown) definindo o que gerar
2. Reconhecimento de Diretório — Escaneia a saída existente para encontrar o número de iteração mais alto
3. Implantação Paralela — Inicia 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 unicidade)
4. Gerenciamento de Ondas — Para modo infinito, implanta ondas de 3-5 agentes até o contexto se esgotar

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 da 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 número de iteração mais alto. 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é o contexto ficar 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: Unicidade via Atribuição

Não confie que os agentes se diferenciem 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 de shell de nível de produção que executa o Claude Code em um loop contínuo, criando PRs, aguardando CI e fazendo merge automaticamente. Criado por AnandChowdhary (crédito: @AnandChowdhary).

Loop Central

┌─────────────────────────────────────────────────────┐
│  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. Push + criar PR (gh pr create)                 │
│  6. Aguardar verificações de CI (poll gh pr checks)│
│  7. Falha no CI? → Passagem de correção automática (claude -p)│
│  8. Fazer merge do PR (squash/merge/rebase)         │
│  9. Voltar para main → repetir                     │
│                                                     │
│  Limitar por: --max-runs N | --max-cost $X         │
│            --max-duration 2h | sinal de conclusão   │
└─────────────────────────────────────────────────────┘

Instalação

Aviso: Instale continuous-claude 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 lint" --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 funcionalidade 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] Adicionados testes para o módulo de autenticação (iteração 1)
- [x] Corrigido caso extremo na atualização do 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 ao final. Isso preenche a lacuna de contexto entre invocações independentes de claude -p.

Recuperação de Falhas de CI

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

1. Busca o ID da execução com falha via gh run list
2. Inicia um novo claude -p com contexto de correção de CI
3. Claude inspeciona logs via gh run view, corrige o código, commita e faz push
4. Re-aguarda as 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 o tempo decorrido
--merge-strategy squash	squash, merge ou rebase
--worktree <nome>	Execução paralela via worktrees do git
--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 de 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 se o sistema de tipos do TypeScript funciona (testar typeof x === 'string')
• Verificações de tempo de execução excessivamente defensivas para coisas que o sistema de tipos já garante
• Testes para comportamento do framework em vez de lógica de negócio
• Tratamento de erros excessivo 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 fica hesitante sobre TODOS os testes
• Ele pula testes de casos extremos legítimos
• A qualidade degrada de forma imprevisível

A Solução: Passagem Separada

Em vez de restringir o Implementador, deixe-o ser minucioso. Depois, 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: Desemburrecer (contexto separado, limpeza focada)
claude -p "Revise todas as alterações na árvore de trabalho. Remova:
- Testes que verificam comportamento da linguagem/framework em vez de lógica de negócio
- Verificações de tipo redundantes que o sistema de tipos já impõe
- Tratamento de erros excessivamente defensivo para estados impossíveis
- Declarações console.log
- Código comentado

Mantenha todos os testes de lógica de negócio. Execute o conjunto 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."

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

  # Verificar
  claude -p "Execute build + lint + testes. Corrija quaisquer falhas."

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

Insight Chave

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

---

6. Ralphinho / Orquestração DAG Orientada por RFC

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

…

[truncado para tradução]