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) | |
|---|---|---|
| Executor | GPT-6.1 Terra, xhigh | GPT-6.2 Sol, high |
| Investigação | GPT-6.1 Sol, high | GPT-6.2 Astra, high |
| Front-end | o executor | frontend-engineer: Sol 6.2 com prompt de UI |
| Consultas | o executor | scout: Terra 6.1, só leitura |
| Revisão de código | GPT-6 Astra, só em diff relevante | GPT-6.2 Astra, em toda tarefa, em três camadas |
| Revisão do plano | não existia | Claude Opus 5.5, xhigh, em toda rodada |
| Spec | sem casos de borda | Edge cases obrigatório e Bite check |
| Execução | paralelo quando era óbvio | ondas com portão, até 4 tarefas simultâneas |
| Orquestrador | lê o diff e corrige o que é pequeno | lê relatórios e não escreve código |
| Entrada | eu 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:
| Fase | Tarefas | Apontados | Passariam | Uso normal | Confirmados | Spec |
|---|---|---|---|---|---|---|
| 01–07/11: sem revisor de rotina | 173 | 1 | n/d | n/d | 0 | 0 |
| 07–14/11: fluxo do primeiro post | 184 | 88 | 83 | 35 | 8 | 1 |
| 14–17/11: revisão automática e de plano | 161 | 247 | 175 | 74 | 99 | 318 |
| 17–21/11: GPT-6.2, três camadas, bite check | 130 | 489 | 375 | 159 | 131 | 157 |
| 21–22/11: ondas, portões e relatórios | 53 | 135 | 96 | 41 | 50 | 39 |
| v2 (as três últimas fases) | 344 | 871 | 646 | 274 | 280 | 514 |
| Total | 701 | 960 | 729 | 309 | 288 | 515 |
Cada coluna conta uma coisa diferente (n/d é não medido):
- Apontados: achados
blockeroumajorde 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.
- Apontados
- Teriam passado
- Confirmados
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.
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.tsAs 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.shrecusa 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ó:
- Completude: cada critério de aceite vira atendido, não atendido ou não verificável, com evidência.
- Lógica e casos de borda: corrida, remontagem, dado velho, limites, caminhos de erro.
- 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:
| Executor | Blocker/major | Critérios não atendidos | Itens largados |
|---|---|---|---|
| GPT-6.1 Terra, xhigh | 14 | 17 | 4 |
| GPT-6.2 Sol, medium | 11 | 9 | 0 |
| GPT-6.2 Sol, high | 12 | 12 | 0 |
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
continuepor 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.