Lights-on: por que a software factory mantém um humano no merge
Quem tentou tirar o humano do código voltou a ler o código; veja o que o T25 mantém no merge, no gate de risco e no teto de diff.
Read in English Versão em Markdown

Três fontes que apontam para o mesmo limite
Dex Horthy, da HumanLayer, deu a palestra Why Software Factories Fail. O argumento central: um harness bem feito não basta. A equipe dele tentou lights-off e, segundo ele, os agentes começaram a travar depois de três a seis meses, em problemas que ninguém lia mais. Para ele, o problema está no sinal de recompensa. O agente ganha se o problema foi resolvido e nada quebrou. Esse sinal não penaliza design ruim nem perda de manutenibilidade, e esse custo só aparece meses depois. A saída que ele propõe é alinhar antes de codar: arquitetura, depois o desenho do programa (tipos, assinaturas, call stacks), depois fatias verticais. E continuar lendo o código.
O pasquadev respondeu num vídeo descrevendo como o time dele trabalha: PRD revisado com produto, revisão entre staff engineers antes de codar, PRs de umas 300 linhas. Ele também usa a arquitetura hexagonal como critério. Quanto mais fundo o diff chega no domínio, mais precisa de humano; na periferia, menos. Ele mesmo diz que ainda está pensando nisso e que não implementou.
O CRBugBench (arXiv:2610.13668) mede revisores automáticos em PRs que introduziram bugs conhecidos. A métrica é recall@k: a fração de tarefas em que o bug conhecido aparece entre os k primeiros achados. Com o Claude Opus 5 no Copilot CLI, o paper reporta 71,9% no top-5. Esse número é a média de dois conjuntos: 79,6% dos bugs achados antes do merge e 64,2% dos achados depois. A mesma análise traz um detalhe que pesa. 95,6% das execuções inspecionam o arquivo com defeito, mas só 80,2% geram um achado para ele, e 56,2% acertam o bug. Localizar não é diagnosticar. O paper também diz que os revisores perdem eficácia em mudanças complexas e em bugs que exigem raciocínio fora do diff. A recomendação é manter um humano responsável por mudanças consequentes e pela manutenibilidade.
Corey Gallon, em outro vídeo, diz que em cerca de quatro de cada dez sessões dele um erro de agente teve importância. O método dele é revisão por agentes, em três níveis que sobem com o risco. Ele admite que não dá para revisar tudo pessoalmente, então o desenho dele não põe um humano em cada passo. A diferença para o T25 está aí: aqui o merge não é delegado.
O que o T25 faz hoje
| Ponto de controle | Como funciona no T25 | Onde está |
|---|---|---|
| Spec | Aprovação humana. Nenhuma promoção de política remove essa etapa. | src/decisions/action-promotion.ts |
| Plano | Por risco: low não pede aprovação de plano por padrão, medium pede, high pede plano e PR, critical exige humano sempre. Cada projeto pode ligar ou desligar o gate. |
src/core/config.ts, requiresPlanApproval em src/core/policy.ts |
| Diff | Teto de 40 arquivos, 2000 linhas e 0,5 de duplicação, configurável. Estourou, a tarefa falha e recebe um handoff com os números. | limits em src/core/config.ts, checkDiffLimits em src/core/policy.ts |
| Caminhos sensíveis | review.sensitive_paths por projeto. Um PR que toca esses caminhos só segue com reconhecimento humano, e o reconhecimento fica amarrado ao digest do diff: se o PR muda, pede de novo. |
merge em src/t25/service.ts |
| Merge | Humano. A factory abre o PR e confere os checks obrigatórios. O merge sai por t25 merge ou pela rota da API, com o nome de quem executou. |
src/cli.ts, src/server/app.ts, merge em src/t25/service.ts |
O veredito do revisor também não tem a palavra final. O T25 recalcula o veredito a partir dos findings: um finding em escopo bloqueia, mesmo que o modelo tenha escrito APPROVE. O caso completo está no post sobre o APPROVE.
O que isso não resolve
Os checks mostram que o caminho certo foi seguido, não que o código está certo. Um diff pequeno pode esconder um bug de regra de negócio que nenhum check pega, e um humano que aprova só o resumo pode deixar passar. Também não há revisão por camada. O sensitive_paths é binário: marca o caminho como sensível ou não, e só acrescenta humano. Revisar a borda da arquitetura com menos gente é uma ideia no roadmap, sem data.
Para o teto de diff em si, veja o post sobre limites de diff. A configuração completa está na referência de configuração.
Como aplicar isso sem o T25
- Ponha o humano no merge. Automatize o resto antes dele, não depois.
- Defina o gate de aprovação pelo risco da task, não pelo hábito do time.
- Defina um teto de diff antes de rodar o agente, e trate estouro como falha, não como aviso.
- Compare a aprovação com a prova do PR (checks, digest, identificador), não com a frase do agente.
Perguntas frequentes
A factory precisa de um humano em todo PR?
O merge é humano por padrão. O que muda com o risco é quanto do trabalho passa por aprovação antes do build: plano, spec e PR. Em tarefa de risco baixo, o plano nem precisa de aprovação.
O T25 faz merge sozinho quando o review aprova?
Não. Um review aprovado leva a tarefa até o PR. O merge exige um comando ou uma chamada à API, registra quem executou e só acontece depois dos checks obrigatórios do repositório.
Lights-off é sempre ruim?
Não. O paper do CRBugBench recomenda dispensar supervisão só em mudanças estreitas e de baixa consequência, calibradas no próprio repositório. O erro é tratar automação ampla como padrão sem medir o que ela deixa passar.
Dá para usar a ideia sem o T25?
Dá. As quatro etapas da lista acima não dependem da ferramenta. O T25 acrescenta que o gate, o teto de diff e a checagem de merge já estão no pipeline, com decisão e ator registrados.