Pedir código para um agente é fácil. O difícil é saber o que entrou no branch depois que ele terminou. Se o mesmo modelo planeja, implementa e ainda diz que está tudo certo, a revisão fica comigo, e eu começo do zero.
Por isso, no meu fluxo de trabalho, esses papéis são separados. Uma sessão do Claude Opus 5.5, que eu chamo de orquestrador, pensa, decide e revisa. A execução vai para agentes do pi, cada um na sua própria worktree. Nada entra no branch de trabalho sem passar pela revisão e pelos checks do orquestrador.
Uso esse fluxo nos meus projetos, não só em um. Os exemplos e diagramas deste post vêm do Ergit.
Quem faz o quê
São quatro papéis. O orquestrador é a sessão com que eu converso. Os outros três são perfis de agente do pi, todos chamados pelo mesmo script, o run.sh da skill delegate:
- Fast Executor (GPT-6.1 Terra, thinking xhigh): implementa tarefas especificadas, responde consultas e faz edições mecânicas. Toda tarefa começa nele.
- Deep Engineer (GPT-6.1 Sol, thinking high): bugs que pedem investigação, refactors entre módulos e o que o Terra não conseguiu fechar.
- Reviewer (GPT-6 Astra, thinking medium): só leitura. Compara o diff com a spec e devolve um veredito com os achados.
Ao lado deles ficam duas ferramentas: o Codex CLI, usado só para gerar imagens, e o juiz JEV, que classifica e valida texto ou imagem.
Cada perfil define o modelo, o nível de thinking e as ferramentas. Para mudar um papel, eu edito o perfil, nunca o run.sh.
Escolhi o pi como executor por velocidade e por custo de contexto. Nas medições de 7 de novembro, ele chegou ao primeiro token em cerca de 2 s, contra 4 a 17 s do codex exec, e mandou de 5 a 7 vezes menos tokens de entrada por tarefa.
Tem um ponto importante aqui: com acesso ao bash, o pi roda sem sandbox. O isolamento vem de outro lugar. Cada tarefa roda numa worktree separada, com um ambiente limpo, sem os segredos do meu shell, e tudo passa pela revisão do orquestrador antes de entrar.
Por que o Claude planeja e o GPT executa
Os dois modelos têm jeitos diferentes de trabalhar, e o fluxo foi montado em cima disso.
Os modelos GPT, no Codex ou no ChatGPT, seguem instruções muito bem. Fazem o que a spec pede, do jeito que ela pede. O Claude tem uma proatividade maior: quando falta alguma coisa no pedido, ele percebe e completa.
No planejamento, essa proatividade ajuda. Os buracos que ficam quando eu descrevo uma tarefa acabam preenchidos pelo Claude, e as instruções que ele repassa aos executores chegam mais refinadas. Na execução, eu quero o contrário: um modelo que siga a spec à risca. Juntando as duas coisas, o GPT recebe uma spec melhor e rende mais, justamente porque segue bem o que está escrito.
A vida de uma tarefa
Todo trabalho começa com um card de PBI no Todoist. O orquestrador lê o contexto (o PRD, a RFC da área e o que já está registrado no Lambda Memory) e só então pergunta se o design está aprovado. Se não estiver, a gente discute antes. Nada é delegado sem design.
Com o design aprovado, o orquestrador decompõe o trabalho e escreve a spec. O run.sh new cria a worktree, o branch dlg/<nome> e grava a spec. O agente implementa, testa e commita. Depois, o orquestrador lê o diff inteiro, roda os checks e integra com cherry-pick no branch de trabalho, nunca direto na main.
Um detalhe importante: a worktree nasce do HEAD. Mudança que não foi commitada no repositório principal não vai junto.
Qual comando usar
A primeira pergunta é sempre se aquilo pode ser delegado. Design, regra de domínio, segurança, deploy, git remoto e Todoist ficam com o orquestrador. Depois disso, é descer a escada: a primeira resposta "sim" diz o comando.
Na prática, quase tudo cabe em poucos comandos:
R=~/.claude/skills/delegate/run.sh
# só lê, não cria nem apaga arquivos
$R query -- "onde o merge_lock é adquirido?"
# cria a worktree e o branch dlg/i18n-billing, grava a spec e implementa
$R new i18n-billing -- "…"
# segue a mesma sessão, com o mesmo agente
$R continue i18n-billing -- "…"
# veredito e achados do Reviewer
$R review i18n-billing
# apaga a worktree depois de integrar
$R remove i18n-billingQuando o agente trava
Toda tarefa começa no Fast Executor. Se ele devolver UNSURE:, falhar na verificação ou parar no meio de um plano, o orquestrador tenta um continue com uma instrução objetiva. Se ainda assim travar, a tarefa sobe para o Deep Engineer. O último recurso é reescrever a spec ou fazer na mão.
Os modelos GPT costumam parar depois da primeira tarefa de um plano e devolver o relatório. Por isso, a spec nomeia cada tarefa e diz que todas devem ser commitadas na mesma rodada.
Várias tarefas ao mesmo tempo
Tarefas independentes saem juntas: um run.sh new por tarefa, cada uma em segundo plano e na sua própria worktree. A regra que evita dor de cabeça é dividir o trabalho para que cada tarefa mexa em arquivos diferentes. Assim, os cherry-picks entram sem conflito.
O Reviewer não substitui a revisão
O Reviewer custa tempo, então só entra onde compensa: diffs com mais de 150 linhas, mais de quatro arquivos ou que tocam uma área sensível. Auth, tokens, concorrência, billing, migrations e contratos de API entram nessa lista. No Ergit, as regras de gate, scope, merge e push também.
Mesmo assim, os achados dele são insumo, não decisão. Cada um é conferido no código antes de virar ação, e o orquestrador continua lendo o diff inteiro.
A spec é o que mais pesa
Em 470 rodadas de teste, o formato do prompt (rótulos, XML ou prosa) não mudou o resultado. O que muda é a especificação. Toda delegação leva os mesmos campos, escritos pelo orquestrador:
Context: PBI-014 (i18n). Leia antes o design em
docs/superpowers/specs/2026-10-22-pbi-014-i18n-design.md
Goal: mover para o catálogo as mensagens hard-coded
da tela de billing, em EN e PT_BR.
Scope: platform/web/src/views/billing/,
platform/web/src/i18n/{en,pt-BR}/billing.ts
Out of scope: outros catálogos; lógica de billing.
Rules:
- Glossário fica em inglês no pt-BR (merge, token, push).
- Nunca chamar t() no topo do módulo.
Acceptance criteria:
- Com pt-BR, a tela mostra português com acentos.
- O teste de completude passa, sem chave faltando ou sobrando.
Verification: npm run typecheck && npm test
Commits: um commit, cite o PBI-014.
Output format: arquivos alterados e resultado dos testes,
ex.: src/i18n/en/billing.ts:12
Se travar: "UNSURE: <motivo>"Algumas lições saíram dessas rodadas:
- Dê um exemplo literal da saída. Sem exemplo, os caminhos voltaram relativos à pasta pesquisada.
- Não deixe comportamento em aberto. Uma pergunta sem resposta na spec vira uma escolha dividida ao meio.
- Vários passos? Diga que todos entram nesta rodada. Senão o modelo para no primeiro.
- Gates longos ou com sudo ficam com o orquestrador. O agente é instruído a não rodá-los.
Antes de dar por feito
Tudo o que vem do agente é tratado como não confiável até ser conferido. Depois de cada entrega, o orquestrador segue a mesma ordem:
- Lê os erros e qualquer
UNSURE:. - Confere cada
path:linee cada contagem citada, comgrepoused -n. - Lê o diff inteiro, procurando mudança fora do escopo, teste desligado ou atalho.
- Roda a verificação ele mesmo. O "passou" do relatório não conta.
- Ajusta: se for pequeno, corrige direto; se for maior, manda um
continue. - Integra com cherry-pick no branch de trabalho.
- Remove a worktree.
- Me conta o que foi delegado, para qual agente e o que foi verificado.
O que nunca é delegado
Os agentes são executores. Planejamento, instruções e revisões são do orquestrador. Um agente pode responder uma consulta pontual que o orquestrador usa, mas nunca rascunha um documento de design.
Ficam fora da delegação: qualquer coisa sem design aprovado, specs e decisões de arquitetura, regras de domínio (gate, scope, merge, push e auth), decisões de segurança e segredos, deploy, servidores, git remoto e Todoist. E também o caso mais simples de todos: quando explicar a tarefa custa mais do que fazer, o orquestrador faz direto.
Quanto do limite isso consome
Os limites semanais das assinaturas duram a semana toda. Tocando pelo menos cinco projetos ao mesmo tempo, chego perto do reset com 20% a 30% sobrando: em média, uso cerca de 80% do limite do Claude e 70% do Codex.
Parecido com o Elephant-Goldfish do Google
Em outubro, o Google publicou o Elephant-Goldfish Model (anúncio), um plugin para agentes de código que separa dois tipos de sessão. O elefante guarda o contexto do projeto e escreve a especificação, sem escrever código. Os peixinhos-dourados começam sem a memória da conversa e recebem só o documento e os arquivos que ele cita, para revisar a proposta sem herdar os pontos cegos de quem a escreveu. As decisões de arquitetura ficam com a pessoa.
O meu fluxo é bem parecido, e é bom saber que ele não está longe do que as empresas de ponta estão fazendo. O orquestrador faz o papel do elefante: guarda o contexto, conversa comigo e escreve a spec. Os executores e o Reviewer fazem o papel dos peixinhos-dourados: recebem a spec e o código, nunca a conversa.
A diferença está em onde o contexto limpo entra. No modelo do Google, os peixinhos-dourados revisam o design antes de qualquer código. No meu, eles implementam e revisam o diff, e o design passa por mim antes de qualquer delegação.