Blog

9 min de leitura

Workflow agêntico v2: por que refiz o fluxo e quantos erros ele barrou

Uma auditoria do meu próprio uso de agentes mostrou onde o fluxo falhava. A v2 revisa plano e código em toda tarefa e executa em ondas. Aqui estão os erros que ela barrou, o método da conta e o que isso custou.

  • agentes
  • workflow
  • claude
  • gpt
  • code-review
  • pi

O primeiro post sobre o meu workflow saiu em 9 de novembro. Cinco dias depois, resolvi medir se aquele fluxo funcionava de verdade. Funcionava, mas o filtro que mais achava problema só rodava em parte das tarefas.

Esta é a v2. A ideia central continua: o Claude Opus 5.5 planeja comigo, agentes GPT executam em worktrees isoladas e nada entra no branch sem revisão. Quase todo o resto mudou, e agora eu tenho números sobre o que isso barrou.

344

tarefas delegadas na v2, de 14 a 22/11

646

erros que teriam passado, no máximo

≈274

apareceriam em uso normal (faixa de 176 a 374)

514

erros de spec barrados antes de existir código

O que motivou a mudança

Em 14 de novembro, fiz uma auditoria de 30 dias do meu uso de Claude Code: 188 sessões, 356 horas ativas somadas e os registros de cada delegação. Três coisas pesaram.

O filtro que mais achava problema só rodava em parte das tarefas. O reviewer pediu mudanças em 56 de 98 revisões (57%), com mediana de 32 segundos cada. Mesmo assim, a regra reservava ele para diff grande ou área sensível.

A spec travava o executor. Em 79 de 493 relatórios (16%), o executor voltou com UNSURE: por causa de uma contradição ou lacuna na própria spec.

Os mesmos tipos de falha voltavam. Num projeto grande, foram 61 continue para cada 100 tarefas, contra 40 na média dos outros. Cerca de 47% corrigiam achado do reviewer, quase sempre lógica de borda: corrida, componente que remonta, dado velho, limite de fila. Em vários casos, os testes passavam sem pegar o bug. Outros 20% eram tarefa largada no meio, e 30% eram decisões que a spec não previa.

Ou seja, o problema não estava só no modelo. Estava no modelo, nos testes fracos e nos buracos da spec.

A segunda motivação veio uma semana depois, e essa foi comigo. Medindo as sessões, em 14 a 17 de novembro eu escrevia de 100 a 360 palavras por design, com decisões que mudavam o que era feito. De 19 a 21, foram de 5 a 18 palavras: "vamos de A", "pode dale", "vou na sugestão". O orquestrador chegava com a recomendação pronta e eu confirmava. Logo eu, que tinha dito dias antes que o meu foco forte é a etapa de planejamento.

Junto com isso, o orquestrador gastava o contexto dele lendo diff inteiro, quando a função dele é outra. E a gente paralelizava pouco: de 76 rodadas registradas, 45 tiveram uma tarefa só.

O que mudou

Primeiro post (9/11)v2 (22/11)
ExecutorGPT-6.1 Terra, xhighGPT-6.2 Sol, high
InvestigaçãoGPT-6.1 Sol, highGPT-6.2 Astra, high
Front-endo executorfrontend-engineer: Sol 6.2 com prompt de UI
Consultaso executorscout: Terra 6.1, só leitura
Revisão de códigoGPT-6 Astra, só em diff relevanteGPT-6.2 Astra, em toda tarefa, em três camadas
Revisão do planonão existiaClaude Opus 5.5, xhigh, em toda rodada
Specsem casos de bordaEdge cases obrigatório e Bite check
Execuçãoparalelo quando era óbvioondas com portão, até 4 tarefas simultâneas
Orquestradorlê o diff e corrige o que é pequenolê relatórios e não escreve código
Entradaeu conduzia cada etapa/implement, com três paradas para mim

Quantos erros teriam passado

Essa é a pergunta que eu queria responder: se eu tivesse aceitado o que o executor entregou como pronto, quantos erros teriam entrado no código?

Nenhum erro foi reproduzido. Os números vêm dos relatórios dos revisores nas sessões e nos artefatos de cada delegação, 666 revisões só na v2. Separei por fase do fluxo:

FaseTarefasApontadosPassariamUso normalConfirmadosSpec
01–07/11: sem revisor de rotina1731n/dn/d00
07–14/11: fluxo do primeiro post18488833581
14–17/11: revisão automática e de plano1612471757499318
17–21/11: GPT-6.2, três camadas, bite check130489375159131157
21–22/11: ondas, portões e relatórios5313596415039
v2 (as três últimas fases)344871646274280514
Total701960729309288515

Cada coluna conta uma coisa diferente (n/d é não medido):

  • Apontados: achados blocker ou major de lógica ou de critério não atendido, com as repetições agrupadas. Estilo, escopo e qualidade de teste ficam de fora.
  • Passariam: os apontados que já estavam na primeira revisão, ou seja, na entrega que o executor deu como pronta. Os que surgiram durante as correções não existiriam num desenvolvimento direto.
  • Uso normal: li uma amostra de 40 erros e classifiquei cada um. 17 apareceriam em uso normal, 21 dependem de uma condição rara e 2 são cosméticos ou improváveis. A coluna aplica essa proporção de 17 em 40.
  • Confirmados: erros da primeira revisão que uma re-revisão da mesma delegação não apontou de novo. É o piso mais sólido.
  • Spec: achados graves da revisão de plano, antes de existir código. Ficam fora de "passariam", porque nem todos virariam bug.

As colunas não formam um funil. "Uso normal" é uma estimativa por amostra e "confirmados" é uma contagem direta, por isso os dois ficam perto sem um conter o outro.

Erros por fase da v2
  • Apontados
  • Teriam passado
  • Confirmados
14–17/1124717599
17–21/11489375131
21–22/111359650

Número de erros

A última fase tem cerca de um dia de uso. O salto em 17–21/11 vem em boa parte do revisor novo, que acha mais problemas nos mesmos diffs.

Para ficar concreto, três erros da amostra que apareceriam em uso normal, todos corrigidos antes de entrar:

  • Edição que some. Você salva um formulário e começa outra edição enquanto a atualização ainda está pendente. Quando ela volta, a segunda edição desaparece e a tela diz que não há nada para salvar.
  • Um Esc que fecha duas coisas. Digitar @ no campo do canal e apertar Esc fechava o menu de menção e também o painel de membros, e ainda salvava o painel como fechado.
  • Juiz fora do ar contando como erro do modelo. Num benchmark, um 503 do serviço que avalia as respostas virava um julgamento negativo e derrubava a taxa de acerto do modelo testado.

O que esses números não dizem

  • 646 tende a ser um teto. Num desenvolvimento direto, CI, testes ou eu mesmo pegaríamos parte desses erros, e quem escrevesse o código poderia errar diferente.
  • As fases não comparam qualidade entre si. O revisor mudou no meio. No mesmo diff, o Astra 6.2 achou mais problemas que o Astra 6, o que explica boa parte do salto na fase de 17 a 21.
  • A amostra é pequena. São 40 itens classificados numa leitura, com margem de cerca de 15 pontos percentuais. Por isso a faixa de 176 a 374.
  • O agrupamento é aproximado. O mesmo erro reescrito pode contar duas vezes, e dois erros parecidos podem virar um.
  • A primeira fase está subcontada. Quase não havia revisor, então os erros daquelas 173 tarefas não foram medidos.

O custo

A revisão em toda tarefa aparece na mesma conta, do outro lado.

Rodadas de correção por tarefa
01–07/110,31
07–14/110,46
14–17/110,89
17–21/111,09
21–22/111,43

Número de continue por run.sh new, em todos os projetos

Parte disso é o fluxo fazendo o que deveria: cada achado agora volta ao executor como um continue. Na fase atual, 83 de 91 revisões pediram mudança. Mas a minha meta era esse número cair, e até aqui ele subiu. Ainda não sei separar quanto é revisor mais rigoroso e quanto é executor entregando pior.

Como funciona agora

Tudo começa com /implement e um card. Ele guarda o estado da tarefa, retoma de onde parou e só me chama em três pontos: design, alinhamento do plano e entrega.

card ─► triagem ─┬─ fix ─────► design curto
                 └─ feature ─► eu descrevo, depois o design
                                     │  parada 1
                                     ▼
                  plano em ondas ─► revisão do plano
                                     │  contradição? parada 2
                                     ▼
       onda 0 (contrato) ─► portão ─► onda 1 (até 4) ─► portão
                                     │
                                     ▼
                  revisão final ─► entrega (parada 3)

Eu voltei para o planejamento

Agora o card é classificado antes de tudo. Um fix continua com design curto e uma aprovação. Numa feature, o orquestrador não pode chegar com a resposta: primeiro ele me faz perguntas abertas, sem opções, sobre o problema, o que é sucesso e o que seria um fracasso mesmo funcionando. Só depois vêm as abordagens.

O plano também pode voltar para mim, mas só em três casos: uma contradição que obriga a escolher entre dois comportamentos, uma lacuna do design que muda o que o usuário vê ou a arquitetura, ou um contrato novo que o design não descrevia. Sem isso, ele segue. Um alinhamento que só pede "ok" conta como falha do fluxo.

Revisão antes do código

Antes de qualquer delegação, um Claude Opus 5.5 em xhigh lê o design, o plano e todas as specs da rodada, procurando contradição, comportamento em aberto, verificação que não roda e tarefas paralelas mexendo no mesmo arquivo. É daí que vêm os 514 erros de spec.

A spec também ficou mais exigente. Edge cases é obrigatório, com entrada e resultado esperado, e o run.sh recusa a spec sem ele.

Ondas

Uma rodada é dividida em ondas. A onda seguinte só começa com a anterior integrada e verificada.

Onda 0 · contrato
  team-channel-contract  fast-executor      core/src/types.rs, ui/src/types.ts
Onda 1 · depende da onda 0
  channel-backend        fast-executor      core/src/channel/
  channel-ui             frontend-engineer  ui/src/channel/
  mention-parser         fast-executor      core/src/mention.rs
Onda 2 · depende da onda 1
  channel-e2e            frontend-engineer  ui/e2e/channel.spec.ts

As regras são poucas:

  • Um dono por arquivo. Duas tarefas da mesma onda nunca tocam o mesmo caminho.
  • Arquivos centrais (rotas, registros, configuração, lockfiles, catálogos de i18n) só mudam na onda 0 ou numa tarefa de integração.
  • A onda 0 só existe quando há contrato: tipos, interfaces, schema e rotas, sem lógica.
  • No máximo 4 tarefas ativas por sessão. O run.sh recusa a quinta.
  • Portão entre ondas. Testes, build e typecheck no branch integrado, mais uma revisão da onda para pegar a costura entre tarefas que nenhum revisor individual vê.

Revisão em três camadas e o teste que morde

Todo diff é revisado automaticamente, numa passada só:

  1. Completude: cada critério de aceite vira atendido, não atendido ou não verificável, com evidência.
  2. Lógica e casos de borda: corrida, remontagem, dado velho, limites, caminhos de erro.
  3. Testes e escopo: algum teste passaria sem a mudança? Cada trecho do diff corresponde a um item da spec?

Antes do reviewer, o run.sh roda checagens mecânicas: testes desligados, TODO novo, arquivo fora do escopo, arquivo de uma tarefa vizinha. E, quando a spec tem Bite check, ele copia a worktree, desfaz só o código de produção e roda os testes. Se ainda passam, eles não provam nada, e isso vira achado.

O orquestrador parou de ler diff

Ler diff sujava o contexto de quem precisa planejar, e isso piora com quatro tarefas por onda. Agora o orquestrador lê o veredito, os achados, as checagens e o relatório do executor. Achado de código volta direto para o executor. Se o executor discordar, responde com DISPUTE: e o Astra arbitra.

O risco é o revisor virar a única barreira. No teste comparativo, o Astra 6 aprovou uma tarefa com um bug real de cancelamento, que o 6.2 pegou. Por isso ficaram três exceções em que o orquestrador abre o diff daquela tarefa: área sensível, portão vermelho com tudo aprovado e o mesmo achado de volta depois de dois continue.

O que testei nos modelos

Antes de fixar os papéis, rodei quatro tarefas reais que tiveram achados na época, a partir do mesmo commit e com a spec original:

ExecutorBlocker/majorCritérios não atendidosItens largados
GPT-6.1 Terra, xhigh14174
GPT-6.2 Sol, medium1190
GPT-6.2 Sol, high12120

O Terra largou itens no meio e o Sol não. Entre medium e high, a diferença ficou dentro do ruído, e fiquei com o high porque qualidade vem primeiro. É uma execução por combinação, então vale como indicação, não como benchmark.

Também testei o Claude Sonnet 5.5 no front-end. Nas duas tarefas de UI, ele foi pior em uma e empatou na outra, levou cerca do dobro do tempo e gerou diffs maiores. Hoje o front-end roda no Sol 6.2, com um prompt próprio de UI.

O que ainda está aberto

  • As ondas têm cerca de um dia de uso. Ainda estão em validação, e a próxima feature real é o teste de verdade.
  • Os continue por tarefa precisam cair. Se não caírem, o próximo passo é um segundo revisor, de outra família de modelo.
  • Falta remedir com mais tempo de v2. A fase atual ainda está em andamento, e os números dela vão mudar.