De 31.073 pares de revisão e resposta de desenvolvedores, minerados em 239 repositórios reais do GitHub em que um agente de inteligência artificial revisou o código, 56,3% das revisões foram rejeitadas pelos desenvolvedores; outros 7,3% viraram discussão, e apenas 36,4% foram aceitos [12]. O dado não vem de um produto periférico: vem do CodeRabbit, uma das ferramentas de revisão automática mais adotadas do mercado. A conclusão desconfortável é que, quando um sistema automatizado opina sobre código, o ser humano do outro lado — exausto, sobrecarregado, pressionado a aprovar — rejeita mais da metade do que lê. Se a verificação é o novo gargalo, automatizá-la mal produz um segundo gargalo: a triagem de sugestões ruins.
O diagnóstico que motiva este artigo já foi formulado com precisão no trabalho anterior desta série: agentes de IA geram código mais rápido do que as equipes conseguem revisar, testar e validar, e o custo da engenharia de software migrou da produção para a verificação [1]. Não se repete aqui a anatomia da inversão. Registra-se apenas o essencial: o gargalo deixou de ser digitar e passou a ser acreditar — e nenhuma ferramenta de autocompletar resolve isso, porque o problema não é de velocidade de escrita, é de produção de confiança.
A pergunta que este artigo enfrenta é a seguinte: o que existe, hoje, para automatizar a verificação, e o que a evidência disponível realmente mostra sobre eficácia? A resposta não é uma ferramenta. É uma pilha. A tese defendida aqui é que a verificação automatizada se organiza em oito camadas com economias radicalmente diferentes — e que a única arquitetura defensável é aquela capaz de produzir oráculos independentes do código gerado. Acelerar a revisão humana sem criar oráculos independentes é comprar velocidade com a mesma moeda que causou o problema. As oito camadas estão numeradas na Tabela 1; as seções a seguir agrupam algumas delas por afinidade.
1. Especificação como fonte da verdade: o contrato antes do código
A primeira camada ataca a causa mais profunda da crise de verificação: a ausência de um enunciado contra o qual verificar. Se ninguém disse, de forma precisa, o que o software deve fazer, nenhum teste pode estar errado — porque não há referência. O spec-driven development (SDD) propõe inverter a ordem: a especificação deixa de ser documentação produzida depois e passa a ser o artefato primário, do qual o código é derivado. Em vez de o agente receber um prompt e devolver código, ele recebe um contrato e devolve uma implementação que deve satisfazê-lo.
O GitHub Spec Kit materializa essa ideia em uma CLI open source sob licença MIT. O fluxo é sequencial e deliberadamente burocrático: um comando estabelece uma "constituição" do projeto (princípios inegociáveis), outro produz a especificação funcional, outro o plano técnico, outro a lista de tarefas, e só então a implementação é gerada [2]. A versão 1.0 chegou em agosto de 2026, e o repositório já passa de 130 mil estrelas no GitHub [2] — um sinal de adoção que nenhuma ferramenta de nicho atinge por acidente. A Amazon seguiu caminho semelhante com o Kiro, IDE agêntico lançado em 14 de julho de 2025 [3], que gera três artefatos encadeados: requirements.md, com critérios de aceitação em notação EARS (Easy Approach to Requirements Syntax), design.md e tasks.md [20]. O EARS usa a forma "QUANDO
A promessa é elegante: o erro deixa de ser encontrado no código e passa a ser encontrado na intenção, onde é muito mais barato. A limitação, porém, é brutal, e é preciso dizê-la sem anestesia: não existe, até o momento, evidência quantitativa publicada e revisada por pares de que o SDD reduza defeitos em produção em proporções mensuráveis. As 130 mil estrelas medem popularidade, não eficácia [2]. O Kiro não publicou taxa de defeitos comparativa [3]. O que existe é plausibilidade mecanística e testemunhos de adoção.
Há um segundo problema, mais sutil e mais grave. Se o mesmo modelo de linguagem escreve a especificação e a implementação, a especificação não é um oráculo independente — é o mesmo erro dito duas vezes com palavras diferentes. A camada 1 só entrega o que promete quando a especificação é escrita ou aprovada por alguém que não escreveu o código, e quando os critérios de aceitação em EARS são convertidos em testes executáveis. Sem isso, produz-se spec theater: documentos impecáveis que ninguém lê e que nenhum teste consulta.
2. Fabricar oráculos: testes guiados por mutação e testes baseados em propriedades
A segunda camada abandona a pergunta "o código está certo?" e adota uma substituta mais tratável: "os testes conseguiriam perceber se o código estivesse errado?". A técnica é antiga — teste de mutação —, mas a IA generativa a transformou em algo economicamente viável. O ciclo é: injetam-se defeitos artificiais no código (mutantes); roda-se a suíte de testes; todo mutante que sobrevive indica uma região do código que os testes não cobrem de fato. Historicamente, o custo era humano: alguém precisava escrever testes para matar cada sobrevivente. Agora o custo é de inferência.
O caso mais bem documentado vem do Meta. Foster, Gulati, Harman e colegas descrevem o sistema ACH, aplicado a 10.795 classes Kotlin de Android em sete plataformas, que gerou 9.095 mutantes e, a partir deles, 571 testes novos; em test-a-thons do Messenger e do WhatsApp, engenheiros aceitaram 73% dos testes produzidos, e 36% foram julgados relevantes para privacidade [4]. A leitura ingênua celebra os 73%. A leitura atenta faz duas perguntas que a própria aritmética sugere: 571 testes para 9.095 mutantes significa que a cobertura de mutação efetivamente atacada é uma fração pequena do total, e "aceitação por engenheiro" é um critério de qualidade social, não de detecção de defeito real.
A variante complementar é a geração no momento da mudança, e não sobre a base inteira. Becker, Chen, Cochran e colegas relatam no Meta o just-in-time catching test generation, desenhado para prevenir bugs em sistemas de backend com centenas de milhões de linhas de código [5]. Em vez de perseguir cobertura global, o sistema olha para o diff e gera o teste que pega a regressão plausível daquela alteração específica. Os números do estudo ajudam a calibrar a expectativa: em 22.126 testes gerados, métodos sensíveis à mudança produziram 4 vezes mais candidatos a captura do que testes de endurecimento; avaliadores baseados em regras e em LLM reduziram em 70% a carga de revisão humana; e, de 41 capturas reportadas a engenheiros, 8 eram defeitos reais — 4 deles teriam causado falhas sérias [5]. A mudança de escopo é decisiva: cobertura é uma métrica de estoque, e o que interessa ao revisor é o fluxo — o que esta mudança pode quebrar, agora.
A terceira abordagem dentro desta camada troca exemplos por invariantes. Testes baseados em propriedades (PBTs) não verificam casos, verificam leis que devem valer para todo o espaço de entrada — "ordenar uma lista e ordená-la de novo devolve o mesmo resultado", "serializar e desserializar é identidade". Vikram, Lemieux, Sunshine e Padhye investigaram se LLMs conseguem escrever bons PBTs e propuseram três critérios de avaliação: validade, solidez e cobertura de propriedades, esta última uma métrica nova; a implementação e a avaliação usaram a biblioteca Hypothesis, para Python [6]. Os resultados são animadores e limitados ao mesmo tempo: na melhor combinação de modelo e prompt, bastaram em média 2,4 amostras para obter um PBT válido e sólido, mas o melhor modelo (GPT-4) sintetizou PBTs corretos para apenas 21% das propriedades extraíveis da documentação das APIs [6] — ou seja, os modelos cobrem uma parte pequena das leis que importam. Bibliotecas como o Hypothesis reduzem (shrinking) automaticamente um caso que falha a um contraexemplo mínimo [17]; o LLM escreve a lei, o framework encontra o caso que a viola.
A limitação comum às três técnicas é a mesma que assombra toda a camada: o oráculo e o objeto são gerados pelo mesmo modelo. Um teste escrito por quem escreveu o código testa a consistência interna da implementação, não a correção em relação ao mundo. O escore de mutação mitiga isso parcialmente, porque o mutante é gerado por regra sintática, não por um modelo — é o primeiro oráculo verdadeiramente externo da pilha.
3. Verificação formal assistida por LLM: a camada que prova
Se as camadas anteriores acumulam evidência, a quarta produz prova. A "vericodificação" — geração de código formalmente verificado a partir de especificações formais — é o oposto filosófico do vibe coding: em vez de gerar código e ver o que acontece, o modelo precisa produzir, junto com o programa, uma demonstração de que ele satisfaz a especificação, e um verificador mecânico checa a demonstração. O LLM propõe; o demonstrador decide. É o único arranjo da pilha em que a saída final não depende de confiança no modelo.
O problema era a ausência de base comparativa. Bursuc e colegas construíram um benchmark com 12.504 especificações formais — 3.029 em Dafny, 2.334 em Verus/Rust e 7.141 em Lean, das quais 6.174 inteiramente novas — e mediram a taxa de sucesso de LLMs de prateleira: 82% em Dafny, 44% em Verus/Rust e 27% em Lean [7]. Nenhum outro número nesta área é tão informativo quanto a disparidade entre esses três. A diferença não está no modelo, que é o mesmo; está no verificador. Dafny automatiza a prova com apoio de solvers SMT e esconde a matemática; Lean exige que o modelo construa a demonstração passo a passo, em um jogo de xadrez sem lances ilegais. A lição de engenharia é direta: na verificação formal assistida por IA, o gargalo é a automação do verificador, não a capacidade do gerador.
A segunda lição é econômica, e ela remonta à tese deste artigo. A vericodificação desloca o custo para a especificação formal, que é escrita por humanos e é notoriamente difícil. O benchmark mede a geração a partir de especificações já prontas e curadas [7]; o mundo industrial raramente as tem. E há a aritmética da composição, que nenhum artigo celebra e que qualquer arquiteto deveria temer: se cada especificação é resolvida com 82% de probabilidade, um módulo com cem especificações, se cada uma fosse tentada uma única vez e de forma independente, teria chance de verificação completa da ordem de 0,82¹⁰⁰ — aproximadamente 2,4 × 10⁻⁹. Na prática há novas tentativas e reparo de provas, e a conta não é tão sombria; mas a direção do efeito é real. Verificação formal não é um interruptor; é um imposto cumulativo. Por isso ela pertence a núcleos pequenos e críticos — criptografia, alocação de memória, protocolos de consenso, lógica de cobrança —, e não ao repositório inteiro.
4. O funil do CI: seleção de testes e segurança no pipeline
A quinta camada não verifica nada de novo; ela decide o que vale a pena verificar. Com agentes gerando mudanças em volume, o problema deixa de ser a existência de testes e passa a ser o tempo de fila. A solução mais estudada é a seleção preditiva de testes do Meta: um modelo aprende, a partir do histórico, quais testes têm probabilidade de falhar para uma dada mudança, e executa apenas esse subconjunto. Machalica e colegas relatam a redução do custo de infraestrutura de testes pela metade, mantendo a detecção de mais de 95% das falhas individuais de teste e de mais de 99,9% das mudanças defeituosas [8]; o blog de engenharia do Meta descreve o mesmo sistema como um modelo probabilístico (árvores de decisão com gradient boosting) treinado sobre um grande histórico de mudanças de código e resultados de testes [16].
O caso mais revelador, porém, é o da Anthropic, porque expõe o atrito real. Segundo a própria empresa, os engenheiros passaram a entregar oito vezes mais código por trimestre do que entre 2021 e 2025, cerca de 80% dele escrito pelo Claude, os testes cresceram dez vezes — e o volume de jobs de CI cresceu 25 vezes em seis meses [9]. A solução adotada pertence à mesma família da do Meta: um serviço de test impact analysis com duas peças — um "ouvinte" que registra o resultado de cada teste em cada execução de CI, formando um histórico por teste, e um "seletor" que lê esse histórico, combinado com a relevância dos pacotes alterados, para decidir quais testes cada pull request executa [9]. O dado mais instrutivo do relato não é a técnica, mas o caminho até ela: três remendos sucessivos — mais núcleos, fragmentação, reinícios diários — duraram 70 dias, 29 dias e menos de um dia antes de a arquitetura ser refeita [9]. Escalar a verificação por força bruta tem prazo de validade curto.
Aqui cabe a posição mais arriscada deste artigo. A literatura — e a prática das duas empresas — celebra a seleção baseada em histórico, mas o desenho tem um vício estrutural que raramente aparece nas conclusões: o modelo aprende com o histórico de execuções, e um teste que nunca roda nunca falha, logo nunca entra no conjunto de treino como relevante. É um laço de realimentação que erode a cobertura de forma silenciosa. Os 99,9% de detecção de mudanças defeituosas [8] são uma média histórica, não uma garantia por mudança — e o 0,1% restante, distribuído ao longo de milhares de commits por dia, é exatamente onde os incidentes caros nascem. Seleção de testes é uma aposta com expectativa favorável, não um oráculo.
A sétima camada — segurança — tem a evidência mais limpa de todas, porque o resultado é binário. O GitHub Copilot Autofix, acoplado ao motor de análise estática CodeQL, reduziu, no beta público de 2024, a mediana de tempo entre o alerta e o commit da correção para 28 minutos, contra 1,5 hora (90 minutos) quando o desenvolvedor corrige à mão; a empresa reporta correção três vezes mais rápida no geral, sete vezes em cross-site scripting e doze vezes em injeção de SQL [13]. O Semgrep ataca o mesmo problema por outro ângulo, com regras que a equipe escreve, versiona e revisa, e um motor de análise de fluxo de dados com rastreamento de contaminação (taint) [18] — o que, num mundo de código gerado, tem a virtude de ser um oráculo que o modelo não escreveu. O limite é epistemológico: análise estática encontra as classes de defeito que alguém já pensou em descrever. Um artigo recente sobre disputas lógicas de concorrência em drivers Rust no Linux mostra que, mesmo quando a memória é segura por construção, novas classes de erro exigem análises novas [19].
Tabela 1 — As oito camadas em perspectiva
| # | Camada | O que verifica | Custo marginal | Maturidade da evidência | Ferramentas | Métrica-âncora |
|---|---|---|---|---|---|---|
| 1 | Especificação | intenção, completude, consistência | baixo por spec; alto de disciplina | emergente, sem estudo controlado | Spec Kit, Kiro | retrabalho por requisito |
| 2 | Testes por mutação | poder de detecção da suíte | médio-alto (inferência) | industrial (Meta) | ACH, PIT, Stryker, mutmut | 73% de aceitação [4] |
| 3 | Propriedades | invariantes sobre entradas | médio | experimental | Hypothesis, QuickCheck, fast-check | validade/solidez [6] |
| 4 | Verificação formal | correção total contra spec | muito alto | nicho, benchmark recente | Dafny, Verus, Lean | 82% / 44% / 27% [7] |
| 5 | Seleção de testes | o que executar no CI | negativo (economiza) | produção consolidada | TIA, PTS | 99,9% de mudanças defeituosas [8] |
| 6 | Revisão por IA | estilo, padrões, riscos difusos | baixo | oferta abundante, eficácia baixa | CodeRabbit, Copilot Review | 7,5% [10] / 73,8% [11] / 36,4% [12] |
| 7 | Segurança | classes de vulnerabilidade | baixo | produção consolidada | CodeQL, Semgrep, Autofix | 28 min vs 90 min [13] |
| 8 | Auditoria de oráculos | a validade dos próprios testes | alto | incipiente | escore de mutação, benchmarks internos | 59,4% das tarefas auditadas com falhas [15] |
5. O revisor sintético: o que a revisão automatizada realmente entrega
A sexta camada é a mais visível e a mais mal compreendida. Revisão de código por IA não verifica comportamento; ela lê o diff e opina sobre padrões, riscos, legibilidade e consistência com o resto do repositório. É inspeção de forma, não de função — e a confusão entre as duas coisas é a origem de quase toda a decepção com a categoria.
Os números, lidos em conjunto, formam um quadro mais interessante do que qualquer manchete. No Google, um sistema de aprendizado de máquina que sugere edições para resolver comentários de revisão passou a responder por 7,5% de todos os comentários de revisão endereçados por autores de mudanças — Frömmgen e colegas apresentaram o resultado no ICSE-SEIP 2024 [10]. Sete e meio por cento soa irrelevante; em uma organização que produz dezenas de milhares de mudanças por dia, é um volume de trabalho humano que simplesmente deixa de existir. Já Cihan e colegas, em estudo sobre revisão automatizada na prática, relatam que 73,8% dos comentários automatizados foram endereçados [11]. E o estudo do CodeRabbit, com 31.073 pares de revisão e resposta minerados em repositórios reais, encontra 56,3% de rejeição [12].
A contradição entre 7,5%, 73,8% e 36,4% não é ruído: são denominadores diferentes. O primeiro mede comentários resolvidos por edição sugerida aceita; o segundo mede comentários que os autores marcaram como endereçados, sem que isso implique, necessariamente, uma alteração de código; o terceiro mede aceitação avaliada por pesquisadores que leram a resposta do desenvolvedor. Quando se padroniza a régua, a revisão automatizada parece entregar valor real em uma faixa estreita: correções mecânicas, renomeações, tratamento de erro ausente, padrões conhecidos. Fora dessa faixa, a rejeição sobe — e as razões apontadas no estudo do CodeRabbit são sugestões inválidas (falsos positivos, redundantes ou fora de escopo) e desalinhamento com a intenção do desenvolvedor e as práticas de código [12].
A defesa da camada precisa, portanto, ser feita com honestidade sobre o que ela é: um filtro de primeira passagem que reduz o custo de achados triviais, não um substituto do revisor humano nem uma forma de verificação de comportamento. Um revisor que lê o diff não sabe se o código faz o que devia; sabe se ele se parece com código que faz o que devia. Em um repositório onde 80% do código é gerado [9], "parecer certo" é exatamente o critério que falha.
6. Os benchmarks mentem: por que oráculos independentes importam
Falta a oitava camada, e ela é a que julga todas as outras. Toda ferramenta desta pilha é avaliada contra um benchmark, e todo benchmark é, ele mesmo, um oráculo. Se o oráculo estiver quebrado, as sete camadas anteriores otimizam ruído com grande eficiência.
Wang, Pradel e Liu mostraram que a pergunta "esta issue foi resolvida?" não tem resposta óbvia no SWE-bench: parte das soluções consideradas corretas passa nos testes sem corresponder ao que os desenvolvedores esperavam, e 29,6% dos patches plausíveis se comportam de forma diferente dos patches de referência — divergências que os testes não capturam [14]. A OpenAI foi além e, em fevereiro de 2026, deixou de reportar o SWE-bench Verified: ao auditar 138 das tarefas mais difíceis do conjunto, encontrou falhas sérias no desenho dos testes ou na descrição do problema em 59,4% delas — inclusive testes que rejeitavam soluções funcionalmente corretas —, além de contaminação, com modelos capazes de reproduzir de memória enunciados e correções [15][21]. O número é devastador por uma razão específica: ele não mede o erro dos modelos, mede o erro de quem os avalia.
Este é o ponto em que a análise deste artigo se afasta do consenso otimista. A indústria trata a verificação como um problema de ferramenta — falta automação, falta cobertura, falta velocidade —, quando o problema central é de independência. Um teste gerado pelo mesmo modelo que gerou o código, um benchmark cujos casos circulam em repositórios públicos, uma revisão feita por um sistema treinado na mesma distribuição de código: todos compartilham a mesma falha. A verificação só vale quando o verificador não compartilha os pontos cegos do verificado, e a única forma de saber se isso ocorre é auditar o próprio verificador — com mutação, com contraexemplos, com especificações escritas antes do código.
A tensão que sobra é de incentivo. Auditar o oráculo não produz demonstração de velocidade; produz más notícias. Nenhum fornecedor vende "descobrimos que nossos testes eram ruins". É por isso que a camada 8 tende a ser a última adotada e a primeira a ser cortada — e é exatamente por isso que ela deveria ser obrigatória.
Tabela 2 — Ferramentas concretas e o que a evidência sustenta
| Ferramenta | Camada | Modelo de licença | Evidência disponível | Limitação principal |
|---|---|---|---|---|
| GitHub Spec Kit | 1 | open source, MIT | v1.0 em ago/2026; +130 mil estrelas [2] | adoção não é eficácia; nenhum estudo de defeitos |
| Amazon Kiro | 1 | proprietário | EARS em requirements.md, design.md, tasks.md [20]; lançado em 14/07/2025 [3] |
sem dados públicos comparativos |
| ACH (Meta) | 2 | interno | 10.795 classes Kotlin; 9.095 mutantes; 571 testes; 73% de aceitação [4] | acoplado ao stack Kotlin e a test-a-thons |
| JIT catching tests (Meta) | 2 | interno | 22.126 testes; −70% de carga de revisão; 8 de 41 capturas eram bugs reais [5] | não replicado fora do Meta |
| Hypothesis | 3 | open source | shrinking automático [17]; base do estudo de PBTs com LLM [6] | exige que alguém formule as propriedades |
| Dafny / Verus / Lean | 4 | open source | 82% / 44% / 27% de sucesso em 12.504 specs [7] | custo de escrever e manter especificações formais |
| Predictive Test Selection (Meta) | 5 | publicado | metade do custo de infraestrutura; 99,9% das mudanças defeituosas [8] | viés de realimentação de rótulos |
| Test impact analysis (Anthropic) | 5 | interno | CI cresceu 25x em seis meses; seletor por histórico de testes e relevância de pacotes [9] | mesmo viés de realimentação da seleção preditiva |
| CodeRabbit | 6 | SaaS | 31.073 revisões; 36,4% aceitas, 56,3% rejeitadas [12] | alta rejeição: sugestões inválidas e desalinhamento com práticas |
| Copilot Autofix + CodeQL | 7 | SaaS | mediana de 28 min contra 90 min (beta de 2024); 3x mais rápido [13] | corrigir rápido não é corrigir certo |
| Semgrep | 7 | open source/comercial | regras escritas pela equipe; análise de fluxo de dados e taint [18] | encontra apenas o que foi descrito |
| Auditoria de benchmarks | 8 | prática | OpenAI deixou de reportar o SWE-bench Verified após achar falhas em 59,4% das 138 tarefas auditadas [15] | todo benchmark é ele próprio auditável |
7. Uma arquitetura de referência e um roteiro de adoção
Nenhuma das oito camadas funciona isolada; o valor emerge da ordem em que se encadeiam e do tipo de falha que cada uma é capaz de interceptar. A arquitetura de referência que se propõe aqui tem seis estágios, do mais barato ao mais caro, com um princípio organizador: quanto mais tarde a camada, mais independente ela precisa ser do modelo que gerou o código.
O estágio zero é o contrato de intenção: toda mudança nasce com uma especificação versionada e critérios de aceitação em notação estruturada, mesmo que redigidos em vinte linhas [3]. O estágio um é o portão local, executado em segundos: análise estática, verificação de tipos, Semgrep com regras internas, detecção de segredos. O estágio dois é a geração de oráculos no pull request: testes guiados por mutação sobre as linhas alteradas [4], testes just-in-time para o diff [5] e propriedades para funções puras [6]. O estágio três é o funil de CI: seleção de testes por histórico e impacto, como fazem Meta e Anthropic [8][9], mas sempre sobre um núcleo obrigatório de testes que roda em toda mudança e com execuções completas periódicas — o antídoto contra o laço de realimentação descrito acima. O estágio quatro é a revisão roteada: o revisor sintético comenta, mas o comentário é classificado por tipo — mecânico, que pode ser aplicado automaticamente no espírito dos 7,5% do Google [10]; duvidoso, que vai para fila humana; e contextual, que é suprimido. O estágio cinco é a prova seletiva: verificação formal restrita a núcleos com invariantes caros [7]. E o estágio transversal, permanente, é a auditoria de oráculos: escore de mutação como métrica de saúde da suíte, benchmark interno construído com problemas que nunca circularam publicamente, e revisão periódica dos testes que ninguém executa há seis meses.
O roteiro de adoção em quatro fases foi desenhado para ser executável por uma equipe de produto comum, sem orçamento de pesquisa.
Fase 0 — Medir antes de comprar (30 dias). Instrumentar o pipeline para responder a três perguntas: quanto tempo entre abrir um PR e fazer merge, qual a taxa de mudanças que quebram o build, e qual o escore de mutação da suíte atual. A maioria das equipes descobre nessa fase que não sabe quais testes realmente importam — e essa descoberta é o pré-requisito de tudo o mais.
Fase 1 — Portão local e segurança (90 dias). Semgrep com regras próprias, CodeQL e Autofix no fluxo de pull request [13], verificação de tipos obrigatória. Meta: reduzir o retrabalho de revisão por achados mecânicos. Custo baixo, retorno rápido, nenhuma dependência de mudança cultural.
Fase 2 — Oráculos e funil (6 meses). Introduzir geração de testes guiada por mutação restrita às áreas de maior risco, e análise de impacto determinística no CI. Meta: cortar o tempo de fila pela metade sem aumentar a taxa de escapes — medida, não presumida. É a fase em que a equipe precisa de disciplina para não desligar a auditoria de mutação quando ela começar a produzir resultados ruins.
Fase 3 — Especificação e prova (12 a 18 meses). Adotar spec-driven development para módulos novos ou de alto risco, com critérios em EARS ligados a testes executáveis, e verificação formal para o núcleo de invariantes críticas. Meta: tornar a camada 1 mensurável — comparar retrabalho por requisito entre módulos com e sem spec.
Conclusão
A inversão de custos descrita no artigo anterior não se resolve comprando a ferramenta certa; resolve-se construindo uma pilha em que cada camada produz um tipo diferente de confiança e em que, ao menos uma delas, o verificador não seja o mesmo sistema que escreveu o código [1]. Os números que sustentam essa arquitetura são concretos: 73% de aceitação em testes gerados por mutação [4], 82% de sucesso em Dafny contra 27% em Lean [7], metade do custo de infraestrutura com 99,9% de detecção [8], 25x de crescimento de CI absorvido por seleção de testes baseada em histórico [9], 28 minutos contra 90 na correção de vulnerabilidades [13].
Mas os números que a desafiam são igualmente concretos, e mais instrutivos: 56,3% de revisões automáticas rejeitadas [12] e 59,4% das tarefas de benchmark auditadas com testes ou enunciados falhos [15]. A conclusão que se extrai dos dois conjuntos não é que a automação da verificação não funciona — é que ela funciona apenas onde o oráculo é independente, e falha exatamente onde o verificador herda os pontos cegos do verificado.
Três direções merecem investimento nos próximos anos. A primeira é tratar o oráculo como artefato de engenharia de primeira classe: versionado, revisado, auditado por mutação e mantido com o mesmo rigor do código de produção — hoje ele é um subproduto. A segunda é transformar o escore de mutação em métrica de saúde do repositório, exibida ao lado da cobertura e não em seu lugar, porque cobertura mede o que foi executado e mutação mede o que seria detectado. A terceira é construir benchmarks internos com problemas que nunca circularam em repositórios públicos: enquanto a avaliação for terceirizada para conjuntos contaminados, toda a pilha estará otimizando contra um alvo que se moveu. A verificação, no fim, é uma disciplina sobre a dúvida — e a dúvida não se automatiza terceirizando-a, mas distribuindo-a para sistemas que não têm interesse em concordar com o código.
Referências
[1] Quântica.ia (2026). O gargalo mudou de lugar: por que verificar código virou o trabalho mais caro da engenharia. Quântica.ia, 21 de outubro de 2026. https://quanticaia.com.br/artigos/verificacao-de-codigo-como-novo-gargalo-a-inversao-de-custos-na-engenharia-de-software-2216/
[2] GitHub (2026). github/spec-kit: Toolkit to help you get started with Spec-Driven Development. GitHub. https://github.com/github/spec-kit
[3] Amazon Web Services (2025). Introducing Kiro. Kiro Blog, 14 de julho de 2025. https://kiro.dev/blog/introducing-kiro/
[4] Foster, C.; Gulati, A.; Harman, M. et al. (2025). Mutation-Guided LLM-based Test Generation at Meta. arXiv:2501.12862. https://arxiv.org/abs/2501.12862
[5] Becker, M.; Chen, Y.; Cochran, N. et al. (2026). Just-in-Time Catching Test Generation at Meta. arXiv:2601.22832. https://arxiv.org/abs/2601.22832
[6] Vikram, V.; Lemieux, C.; Sunshine, J.; Padhye, R. (2023). Can Large Language Models Write Good Property-Based Tests? arXiv:2307.04346. https://arxiv.org/abs/2307.04346
[7] Bursuc, S.; Ehrenborg, T.; Lin, S. et al. (2025). A benchmark for vericoding: formally verified program synthesis. arXiv:2509.22908. https://arxiv.org/abs/2509.22908
[8] Machalica, M.; Samylkin, A.; Porth, M.; Chandra, S. (2018). Predictive Test Selection. arXiv:1810.05286. https://arxiv.org/abs/1810.05286
[9] Anthropic (2026). Agentic coding is straining CI. Here's how we scaled test impact analysis at Anthropic. 14 de setembro de 2026. https://claude.com/blog/agentic-coding-is-straining-ci-heres-how-we-scaled-test-impact-analysis-at-anthropic
[10] Frömmgen, A.; Austin, J.; Choy, P. et al. (2024). Resolving Code Review Comments with Machine Learning. ICSE-SEIP 2024. Google Research. https://research.google/pubs/resolving-code-review-comments-with-machine-learning/
[11] Cihan, U.; Haratian, V.; İçöz, A. et al. (2024). Automated Code Review In Practice. arXiv:2412.18531. https://arxiv.org/abs/2412.18531
[12] Lin, H. Y.; Liang, M.; Thongtanunam, P. et al. (2026). Is Agentic Code Review Helpful? Mining Developers' Feedback to CodeRabbit Reviews in the Wild. arXiv:2607.03316. https://arxiv.org/abs/2607.03316
[13] Hanley, M. / GitHub (2024). Found means fixed: Secure code more than three times faster with Copilot Autofix. GitHub Blog, 14 de agosto de 2024. https://github.blog/news-insights/product-news/secure-code-more-than-three-times-faster-with-copilot-autofix/
[14] Wang, Y.; Pradel, M.; Liu, Z. (2025). Are "Solved Issues" in SWE-bench Really Solved Correctly? An Empirical Study. arXiv:2503.15223. https://arxiv.org/abs/2503.15223
[15] OpenAI (2026). Why we no longer evaluate SWE-bench Verified. OpenAI, fevereiro de 2026. https://openai.com/index/why-we-no-longer-evaluate-swe-bench-verified/
[16] Machalica, M. et al. / Meta Engineering (2018). Predictive test selection: A more efficient way to ensure reliability of code changes. Engineering at Meta. https://engineering.fb.com/2018/11/21/developer-tools/predictive-test-selection/
[17] Hypothesis (2026). Glossary — Hypothesis documentation. https://hypothesis.readthedocs.io/en/latest/glossary.html
[18] Semgrep (2026). Dataflow analysis engine overview. Semgrep Docs. https://docs.semgrep.dev/writing-rules/data-flow/data-flow-overview
[19] Xu, Q.; Sheng, Z.; Chen, Z. et al. (2026). XRust: Detecting Logical Races in Rust Linux Drivers. arXiv:2610.27325. https://arxiv.org/abs/2610.27325
[20] Kiro (2026). Requirements-First Workflow — Feature Specs. Kiro Docs. https://kiro.dev/docs/specs/feature-specs/requirements-first/
[21] GIGAZINE (2026). OpenAI explains that the standard benchmark used to measure AI coding ability is 'no longer meaningful' (título resumido). GIGAZINE, 29 de abril de 2026. https://gigazine.net/gsc_news/en/20260429-swe-bench-verified