Ao vivo 18/11 · Turma 318 nov às 19:00 MSK — aula prática gratuita de agentes de IA · Turma 3 ao vivo começa 23/11Aula 18/11 →Turma 3 (23/11)
LançamentoAnálise · No radarHabr AI→ original

Cinco IAs tentaram corrigir o mesmo bug: duas conseguiram, três quebraram ainda mais

Um autor do Habr deu o mesmo bug de publicação de site a cinco IAs: Claude Code e Codex o corrigiram, e as outras três quebraram ainda mais. Mas não dá para escolher o melhor modelo com base em um único bug: mesmo no SWE-bench Verified, com 500 tarefas, os dez primeiros colocados diferem em apenas 164. Mais perigosa que um bug não corrigido é a alteração que quebra silenciosamente o código vizinho, e isso costuma ser descoberto depois. Por isso, aceite uma correção com base no diff e nos testes que você mesmo rodou, não no relatório da IA.

Processado por IA de Habr AI; editado por Hamidun News
Cinco IAs tentaram corrigir o mesmo bug: duas conseguiram, três quebraram ainda mais
Fonte: Habr AI. Colagem: Hamidun News.
Ouvir artigo
Ficha técnica e números-chave
ParâmetroDados
Fonte originalHabr AI ↗
Editor-chefe
Dado-chave #1No Verified, os dois líderes resolvem 396 tarefas cada, de um total de 500
Dado-chave #2Um mesmo modelo oscila até 29,8 p.p. conforme o harness em que roda
Dado-chave #3Testes reforçados reduziram em 4,2–9,0% a taxa de tarefas resolvidas pelos 10 melhores agentes

Um bug, cinco IAs, dois resultados. O autor de um post no Habr entregou a cinco modelos de IA a mesma correção de um erro na publicação de um site no servidor. Claude Code e Codex consertaram o bug. Os outros três quebraram ainda mais do que já estava quebrado. É tentador colocar os dois primeiros no topo do ranking, mas o próprio autor recusa essa tentação. Em compensação, o experimento mostra bem qual tipo de erro é mais perigoso e como pegá-lo antes que a correção entre no projeto.

Por que um único bug não basta para escolher a melhor IA

Um experimento isolado mostra o jeito de trabalhar de um modelo específico, mas não monta um ranking. Os grandes benchmarks confirmam isso. O SWE-bench Verified é um conjunto de 500 tarefas com verificação automática, extraídas de problemas reais do GitHub e selecionadas por pessoas em conjunto com a OpenAI. Os dois melhores resultados resolvem 396 tarefas cada, de um total de 500. Os dez primeiros colocados diferem em apenas 164 tarefas (Liu e coautores, arXiv). Um teste pareado, que verifica se a diferença entre vizinhos da tabela não é fruto do acaso, não separou nenhum dos 29 pares adjacentes entre os 30 primeiros.

Há ainda um segundo fator: o harness, ou seja, o programa em torno da rede neural, por meio do qual ela lê os arquivos do projeto e executa comandos. Segundo os mesmos autores, para um único modelo a variação entre harnesses chega a 29,8 pontos percentuais na taxa de tarefas resolvidas. Entre todos os 30 primeiros colocados, a variação é de apenas 8,8 pontos. Ou seja, o harness altera o resultado três vezes mais do que a diferença entre o primeiro e o trigésimo lugar. Se 500 tarefas não distinguem os vizinhos, um único bug muito menos: em outra tarefa, o cenário poderia ser diferente.

O que é mais perigoso: um bug não corrigido ou uma regressão silenciosa

Um bug não corrigido aparece de imediato. O perigo está na alteração que faz parar de funcionar algo que funcionava antes. Esse tipo de quebra é chamado de regressão, e costuma ser descoberto mais tarde.

Há duas causas. A primeira são as alterações desnecessárias: o agente mexe em mais do que foi pedido e não verifica o resto. A Anthropic diz com todas as letras na documentação do Claude Code: se o agente não tem nada para executar a fim de saber se o trabalho está pronto, ele para quando o trabalho parece pronto.

O papel dos testes, então, fica com o humano. O benchmark SlopCodeBench (análise no TechRadar) mostrou que o código dos agentes é 2,2 vezes mais verboso e mais confuso do que o de 48 projetos Python mantidos por pessoas. A verbosidade cresceu ao longo da tarefa em 89,8% das execuções, e a confusão, em 80%.

Quanto mais linhas uma alteração toca, maior o espaço para regressão.

A segunda causa são os testes fracos. O código pode passar em todos os testes automáticos e ainda assim deixar de cobrir casos importantes. No trabalho Probe to Generate, os pesquisadores reforçaram os testes e reavaliaram os dez melhores agentes de correção de código. A taxa de tarefas resolvidas caiu 4,2–9,0%. Parte das correções aceitas antes havia passado por brechas nos testes e não fazia tudo o que a tarefa exigia. A conclusão é simples: o relatório da IA dizendo "corrigido" não prova nada. É preciso verificar as alterações e os resultados dos testes.

Como limitar o agente e verificar a correção

Uma descrição de tarefa enxuta reduz o risco antes mesmo de o trabalho começar. O que vale especificar:

  • o arquivo e a função em que está o bug;
  • como reproduzir o bug e qual deve ser o resultado esperado;
  • a proibição explícita de mexer no restante do código;
  • o pedido para mostrar primeiro o plano e escrever o código só depois da sua resposta;
  • um teste que falha antes da correção e passa depois.

As proibições permanentes ficam melhor em um arquivo de regras para o agente, para não precisar repeti-las a cada tarefa. Isso importa também porque, no Claude Code, as novas sessões no terminal e no VS Code começam por padrão no modo automático, em que os comandos são executados sem confirmação um a um. Quanto menos você confirma os passos, mais atenção precisa dar ao resultado final.

Verificação da correção, passo a passo:

  1. Abrir o diff completo e procurar arquivos e funções que não deveriam ter sido tocados. Três linhas em uma função e duzentas linhas em seis arquivos carregam riscos diferentes, embora as duas alterações sejam chamadas de correção.
  2. Comparar as alterações com a tarefa. Uma variável renomeada, uma função vizinha reescrita ou uma validação de entrada removida são motivo para devolver a correção.
  3. Garantir que existe um teste para o próprio bug. Se não existe, pedir que o agente escreva um.
  4. Rodar a suíte completa de testes por conta própria e conferir se o agente não alterou os próprios testes. Se o projeto não tem testes, é preciso primeiro criar um que reproduza o bug.
  5. Repetir a execução depois de cada ajuste: uma nova correção pode afetar o que passou da vez anterior.
  6. Pedir uma segunda opinião. A documentação do Claude Code recomenda delegar a um subagente, isto é, a uma instância separada da rede neural, a revisão do diff com base na especificação e nos casos de borda, sem comentários sobre estilo. Ela também descreve o stop hook: um script que devolve o agente ao trabalho até que a verificação passe.

Como escolher o modelo para o seu projeto

Não dá para apontar um vencedor com base em um único bug. O resultado vem do par formado por modelo e harness, e o ambiente é, em grande parte, configurado por você: modo de confirmações, arquivo de regras, verificações. Na prática, vale entregar as correções ao modelo cujo trabalho é mais fácil de verificar nas suas tarefas: ele altera poucas linhas, escreve um teste para o bug e não mexe em arquivos que não lhe foram pedidos. Isso já fica evidente em algumas tarefas no seu repositório, e uma tabela de líderes não ajuda nesse ponto.

A história tem uma limitação honesta: é um único experimento de um único autor, e o próprio autor ressalva que, com outro bug, tudo poderia ter saído diferente. Mas a conclusão prática não perde força por isso. O modelo mais perigoso é aquele que relata com confiança que corrigiu o bug e mexeu no código vizinho. A decisão sobre aceitar uma correção deve ser de uma pessoa, com base nas linhas alteradas e nos testes que ela mesma executou.

História

Perguntas frequentes sobre a notícia

Por que um único bug não basta para escolher a melhor IA?

Um experimento isolado mostra o jeito de trabalhar de um modelo específico, mas não monta um ranking. Os grandes benchmarks confirmam isso. O SWE-bench Verified é um conjunto de 500 tarefas com verificação automática, extraídas de problemas reais do GitHub e selecionadas por pessoas em conjunto com a OpenAI. Os dois melhores resultados resolvem 396 tarefas cada, de um total de 500. Os dez primeiros colocados diferem em apenas 164 tarefas (Liu e coautores, arXiv).

O que é mais perigoso: um bug não corrigido ou uma regressão silenciosa?

Um bug não corrigido aparece de imediato. O perigo está na alteração que faz parar de funcionar algo que funcionava antes. Esse tipo de quebra é chamado de regressão, e costuma ser descoberto mais tarde. Há duas causas. A primeira são as alterações desnecessárias: o agente mexe em mais do que foi pedido e não verifica o resto. A Anthropic diz com todas as letras na documentação do Claude Code: se o agente não tem nada para executar a fim de saber se o trabalho está pronto, ele para quando o trabalho parece pronto.

Como limitar o agente e verificar a correção?

Uma descrição de tarefa enxuta reduz o risco antes mesmo de o trabalho começar. O que vale especificar: o arquivo e a função em que está o bug; como reproduzir o bug e qual deve ser o resultado esperado; a proibição explícita de mexer no restante do código; o pedido para mostrar primeiro o plano e escrever o código só depois da sua resposta; um teste que falha antes da correção e passa depois. As proibições permanentes ficam melhor em um arquivo de regras para o agente, para não precisar repeti-las a cada tarefa.

ZK
Zhemal Khamidun — CPO da Alpina Digital, gerente de produto do AlpinaGPT. Cria produtos de IA desde 2019. O Hamidun News é um projeto pessoal que virou um agregador em produção com mais de 6.000 leitores.
✦ Hands-On AI Engineering · Hamidun Academy

Build & Ship Production AI Agents Without Boilerplate Code

Start your free 72-hour trial at Hamidun Academy (academy.hamidun.com) — interactive lessons on Claude Code & Cursor, live Tech Radar, and production agent templates.

Start 72h Free Trial →Vibe-Coding Intensive
O que você acha?
Carregando comentários…