← Back to all articles

Duas IAs, uma revisando a outra

Vladimir Dietrich · November 15, 2026 ·4 min read

Há alguns meses eu trabalho com duas inteligências artificiais ao mesmo tempo. Uma, mais cara, pensa: decide o que fazer, escreve a instrução e revisa o resultado. A outra, mais barata, digita: edita os arquivos, roda os testes e devolve um resumo de dez linhas.

Funciona bem. E me ensinou uma coisa que vale fora da programação: o resumo mente por omissão.

O dia em que "testes verdes" não queria dizer nada

Em julho, a IA barata corrompeu a sintaxe de um arquivo e me devolveu um relatório tranquilo: testes verdes. Era verdade. Ela tinha rodado uma bateria de testes que nem carregava o arquivo que ela mesma tinha editado.

Ninguém mentiu. O relatório respondia a uma pergunta ligeiramente diferente da que eu tinha feito, e eu só li a resposta.

Uma bancada com armadilhas

Então parei de escolher o modelo pelo que o fabricante publica e montei uma bancada pequena, com duas tarefas feitas para enganar.

Na primeira, o agente precisa renomear uma opção no projeto inteiro. Só que existe uma chave com o mesmo nome que faz parte de um protocolo de comunicação e não pode mudar. Quem renomeia tudo, quebra a conversa com o outro lado.

Na segunda, ele precisa trocar muitas consultas pequenas por uma consulta em lote. Há cinco regras que a versão nova tem de respeitar, e nenhum teste do projeto confere nenhuma delas. Quem confere é um juiz que o agente não vê.

Passar nos testes, aqui, não basta. Foi de propósito.

O verde que esconde

Em setembro, um dos modelos renomeou a opção no código e deixou duas chamadas com o nome antigo dentro dos próprios testes. Os testes continuaram verdes. O motivo: quando a opção não era reconhecida, o programa usava um valor padrão, e o valor padrão por acaso servia.

Passei a chamar isso de "o verde que esconde". O teste passa, e passa justamente porque parou de testar.

Quem trabalha em laboratório conhece o parente disso: o experimento que "deu certo" porque o controle estava errado.

Mais esforço não comprou resultado melhor

Os modelos têm níveis de esforço: baixo, médio, alto. Eu esperava que o alto entregasse mais. Na minha bancada, não entregou.

Em novembro medi os tokens de cada rodada, que é o que de fato se gasta. O modelo no esforço baixo resolveu as duas tarefas com cerca de 112 mil tokens. O mesmo modelo no esforço médio gastou 2,3 vezes isso e entregou a mesma alteração. Um modo "orquestrador", que distribui passos para um ajudante, gastou cerca de 349 mil para chegar ao mesmo lugar.

Um mês antes, a troca de geração tinha sido ainda mais clara: 165 mil tokens contra 713 mil, com o mesmo resultado e menos da metade dos passos. O modelo antigo não errava. Ele dava mais voltas.

A bancada é fácil demais para separar os modelos em tarefa difícil, e eu sei disso. Ela responde a uma pergunta só: para o trabalho braçal, qual é o mais barato que não cai nas armadilhas?

A bancada também estava errada

Na rodada de novembro, descobri que o comando de teste das próprias tarefas tinha quebrado com uma atualização do Node. Os testes nem chegavam a rodar.

O que salvou a rodada foi o relato dos agentes. Os dezesseis disseram que o comando falhou e mostraram qual comando tinham usado no lugar. Nenhum verde falso. Refiz as contas com o comando certo.

Também aprendi a não comparar rodadas de dias diferentes. O mesmo modelo mediu 165 mil tokens em outubro e 224 mil em novembro, com outra versão da ferramenta e outro jeito de contar. Só comparo número com número da mesma rodada.

O que fica com quem revisa

Uma vez deixei a IA barata conduzir sozinha cinco etapas de um projeto meu. Depois revisei: seis defeitos graves, quatro deles já no ar, e o resumo estava errado nas cinco etapas. Revisar depois custou o mesmo que ter feito direto.

Com instrução escrita e revisão a cada etapa: nenhum defeito grave, e o resumo fiel.

Os defeitos graves não apareceram nos testes que o agente escreveu. Apareceram quando rodei o sistema contra dado real. O agente testa o que escreveu. O erro mora no que ele supôs.

Minhas regras hoje são poucas:

Leio a alteração linha por linha, não o resumo.

Peço a saída real do comando, colada, e não "passou".

Guardo um juiz que quem faz o trabalho não vê.

Meço o gasto, não a impressão de capricho.

Desconfio da minha própria régua, porque ela também quebra.

O código e os resultados de cada rodada estão abertos em github.com/vladimirbrasil/dupla.

Anos atrás eu aprendi isso com gente: quando o resultado é medido só por quem o produziu, todo mundo parece bem. Com máquinas está sendo parecido, por enquanto.

Em resumo, os tokens estão rendendo muito, muito mais com esta dupla camada de empresas diferentes. Sigo assim, por enquanto.

Respostas

Carregando respostas...

Deixe seu comentário

Respondendo a ✕