Em setembro de 2026, engenheiros da Anthropic relataram que o problema de adotar agentes de código não era convencê-los a escrever software: era o encanamento que precisava provar que o software funcionava. O volume de jobs de integração contínua da empresa crescera 25 vezes em seis meses, e partes da arquitetura responsável por selecionar quais testes rodar tiveram de ser redesenhadas para suportar a carga [7]. Nenhuma linha daquele comunicado celebrava velocidade de escrita. O assunto era fila.
Há uma inversão desconfortável embutida nesse episódio, e ela é o tema deste artigo. Durante cinco décadas, a engenharia de software organizou suas ferramentas, seus processos e sua cultura em torno de uma escassez específica: produzir código corretamente era caro, lento e exigia gente muito qualificada. Linguagens de alto nível, frameworks, ambientes integrados, testes automatizados, pipelines de entrega e nuvem foram respostas sucessivas a essa mesma restrição. Os agentes de código — Claude Code, GitHub Copilot, OpenAI Codex, Cursor, Devin — atacam justamente o elo que a indústria passou meio século tentando afrouxar. E, ao afrouxá-lo, expõem o quanto os elos seguintes nunca foram dimensionados para acompanhar.
O diagnóstico pode ser formulado com precisão econômica: estamos chegando ao ponto em que gerar código é mais fácil do que verificar se aquele código deveria existir. A frase parece um aforismo de conferência, mas descreve um deslocamento material de restrição. Se a produção deixa de ser o recurso escasso, o custo marginal de uma mudança de software cai — e todo o sistema de validação a jusante, que opera com capacidade humana finita, passa a absorver um fluxo que não foi projetado para ele.
A tese que este artigo defende é mais estreita e mais incômoda do que o senso comum sobre "IA na engenharia". A adoção de agentes de código não reduz o custo total de entrega na maioria das organizações; ela transfere esse custo para a revisão, para a integração e para a produção de confiança — e transfere de um jeito que as métricas hoje usadas pelos times de tecnologia são estruturalmente incapazes de enxergar. Medir linhas geradas, pull requests abertos ou tarefas concluídas por agente é medir o lado da equação que ficou barato. O lado que ficou caro permanece invisível nos dashboards.
O deslocamento do gargalo
A teoria das restrições tem um corolário simples e impiedoso: melhorar a eficiência de uma etapa que não é o gargalo não aumenta a vazão do sistema — apenas acumula inventário antes da etapa que realmente limita. Aplicada à engenharia de software, essa máxima explica com precisão desconfortável o que aconteceu entre 2024 e 2026. As equipes aceleraram a etapa de implementação e passaram a observar o surgimento de estoques: pull requests na fila, ambientes de teste saturados, revisores sobrecarregados, janelas de deploy disputadas.
O dado da Anthropic é o sintoma mais bem documentado desse transbordamento. Um crescimento de 25 vezes em jobs de CI em seis meses não reflete apenas mais código; reflete que cada mudança passou a disparar validações que antes eram dispensáveis ou raras, e que a infraestrutura de testes precisou ser reconstruída para decidir o que executar [7]. A empresa não relatou ganho de velocidade de entrega como consequência direta. Relatou trabalho de engenharia de infraestrutura.
Do lado do código produzido, os números são mais ambíguos do que a propaganda sugere. Watanabe e colegas analisaram 567 pull requests gerados por Claude Code em repositórios públicos do GitHub e encontraram 83,8% de aceitação; entre os PRs aceitos, 54,9% foram mesclados sem nenhuma modificação [2]. Lido apressadamente, o resultado parece uma vitória retumbante dos agentes. Lido com cuidado, ele descreve outra coisa: considerando o total submetido, apenas cerca de 46% do que os agentes produziram (54,9% de 83,8%) entrou no produto exatamente como saiu da máquina. Os 45,1% restantes dos PRs aceitos exigiram intervenção humana — reescrita, correção de escopo, ajuste de convenção, remoção de código supérfluo. A taxa de aceitação mede a decisão final do revisor; não mede o custo de chegar até ela.
E há o efeito organizacional que a DORA identificou em sua edição de 2025: a inteligência artificial funciona como amplificador, magnificando forças e fraquezas que já existiam [8]. Em 2025, 90% dos respondentes da pesquisa relataram usar IA no trabalho e mais de 80% acreditavam que ela havia aumentado sua produtividade [12]. Times com boa cobertura de testes, pipelines saudáveis e práticas de revisão maduras tendem a extrair ganhos reais. Times com processos fragmentados descobrem que a IA acelera exatamente aquilo que estava errado — inclusive a produção de dívida técnica e a ilegibilidade do próprio código.
O gargalo, portanto, não desapareceu. Ele se mudou para o lugar onde o julgamento humano é insubstituível e onde a capacidade é mais difícil de expandir por contratação: a validação. E aqui aparece o primeiro contraponto honesto. Não há evidência de que a velocidade de geração seja irrelevante; há evidência de que ela é insuficiente. A aceleração é real, mas seu retorno é capturado apenas por organizações capazes de absorvê-la. Para as demais, o resultado líquido pode ser uma pilha maior de trabalho pela frente.
Volume não é valor
Existe uma cena que se repete em empresas que adotaram agentes com entusiasmo. Duas equipes comparam seus relatórios mensais. A primeira exibe 150 pull requests abertos no período, com três agentes rodando em paralelo e um gráfico ascendente de "tarefas automatizadas". A segunda mostra 45. Na reunião, a primeira parece três vezes mais produtiva. No trimestre seguinte, a primeira descobre que o tempo médio de revisão dobrou, que falhas de integração viraram rotina e que duas regressões chegaram à produção.
A pergunta correta nunca foi quantas mudanças o time produz, mas quanto valor cada mudança entrega e a que custo de risco. As métricas de vaidade da era dos agentes — linhas geradas, commits por dia, PRs por desenvolvedor, percentual de código escrito por IA — compartilham um defeito comum: são medidas de insumo, não de resultado. Elas sobem monotonicamente com qualquer aumento de atividade, inclusive com atividade inútil. Código revisável não é código necessário, e um agente é perfeitamente capaz de produzir, com polimento impecável, uma abstração que ninguém pediu.
A evidência empírica reforça que a qualidade do resultado depende muito mais da natureza da tarefa do que do agente escolhido. Pinna, Gong, Williams e Sarro compararam cinco agentes populares — OpenAI Codex, GitHub Copilot, Devin, Cursor e Claude Code — estratificando a análise por tipo de tarefa, e encontraram que o tipo de PR é fator dominante na aceitação: tarefas de documentação alcançam 82,1% de aceitação, contra 66,1% em novas funcionalidades [3]. O Codex, no estudo, manteve taxas consistentes entre 59,6% e 88,6% ao longo de nove categorias de tarefa [3]. A leitura otimista é que existe um agente melhor. A leitura útil é que existe um tipo de trabalho melhor.
Aqui vale assumir uma posição que contraria parte do discurso do setor. A obsessão por benchmarks de agentes — qual deles resolve mais issues, qual escreve mais rápido — está mal direcionada. A variável que explica a maior parte da variação de sucesso não é o modelo, é a decomposição da tarefa. Agentes falham em tarefas mal especificadas, em requisitos que exigem contexto tácito, em decisões que dependem de história organizacional não escrita em lugar nenhum. Nenhum upgrade de modelo resolve isso, porque o problema não está no modelo: está na fronteira entre o que a organização sabe e o que ela consegue articular.
Isso não significa que a escolha de ferramenta seja irrelevante. Significa que o retorno marginal de trocar de agente é menor do que o retorno marginal de investir na formulação de requisitos e nos critérios de aceitação. E significa que um time que mede apenas volume ficará permanentemente incapaz de distinguir as duas coisas — verá apenas que "a IA está funcionando", porque o gráfico sobe.
A segurança do código gerado
O código produzido por modelos de linguagem tem uma propriedade estatística que a indústria preferiu tratar como detalhe: ele é plausível. Foi treinado para parecer correto, e parecer correto é precisamente o que um revisor cansado aceita com mais facilidade. A plausibilidade é o vetor de ataque.
Kharma e colegas conduziram uma avaliação empírica da segurança de código gerado por LLMs, cobrindo cinco modelos e quatro linguagens de programação — Python, Java, C++ e C — sob diferentes métodos de prompting [5]. O resultado é incômodo para quem aposta em engenharia de prompt como defesa: os autores não encontraram reduções estatisticamente significativas na frequência ou na densidade de vulnerabilidades entre os métodos de prompting testados [5]. Em outras palavras, não basta pedir com mais cuidado para obter código seguro. Isso desmonta tanto a ideia de que existe uma "versão segura" a ser homologada pelo departamento de compras quanto a de que um bom template de prompt dispensa a verificação.
Os números da literatura secundária são consistentes em apontar gravidade. Um levantamento da Endor Labs sobre a produção acadêmica recente indica que mais de 40% das soluções de código geradas por LLM contêm falhas de segurança, mesmo nas gerações mais recentes de modelos [9]. Trata-se de um número agregado, com heterogeneidade metodológica considerável — diferentes linguagens, diferentes taxonomias de vulnerabilidade, diferentes definições do que conta como "falha". Mas a ordem de grandeza é difícil de descartar.
O caso OpenSSL mostra o que acontece quando essa realidade encontra um projeto de infraestrutura crítica. Segundo Matt Caswell, diretor-executivo da OpenSSL Foundation, entre maio e julho de 2026 o projeto recebeu, em média, 71 relatórios e consultas de segurança por mês, contra nove por mês no mesmo período do ano anterior [11]. Ferramentas de IA baratearam a varredura de grandes bases de código em busca de padrões suspeitos. O resultado não foi 71 vulnerabilidades reais por mês: foi uma multiplicação de candidatos — muitos deles duplicatas ou bugs de baixo impacto — que ainda assim precisam ser triados por especialistas humanos [11].
Aqui está a armadilha estrutural. A IA expande a capacidade de detecção sem expandir proporcionalmente a capacidade de adjudicação. Em segurança, detecção sem adjudicação é ruído com custo. Cada relatório falso consome tempo de um mantenedor sênior que poderia estar auditando algo real, e a sobrecarga de triagem tem um efeito perverso conhecido: aumenta a probabilidade de que um achado genuíno seja descartado junto com o lixo. O mesmo padrão se replica dentro das empresas, onde agentes geram código, testes, documentação e análises de segurança em volume, e o engenheiro precisa decidir o que daquilo merece confiança.
O paradoxo cabe numa frase que merece ser levada ao pé da letra: a automação aumenta a produção, mas não elimina a responsabilidade do julgamento. Em segurança, essa responsabilidade não é delegável a um scanner, porque o scanner e o gerador compartilham o mesmo tipo de cegueira — ambos operam sobre padrões, e vulnerabilidades exploráveis frequentemente nascem da interação entre componentes que, isoladamente, parecem corretos.
O papel supervisor do engenheiro
A narrativa dominante diz que o engenheiro está se tornando revisor. É uma meia-verdade com consequências práticas ruins, e vale examiná-la com cuidado. O estudo longitudinal de Annie Vella e Kelly Blincoe propôs a expressão "trabalho de engenharia supervisora" (supervisory engineering work) para capturar o deslocamento em curso: a direção, a avaliação e a correção da saída da IA. Entre os participantes, 82% relataram passar menos tempo escrevendo código, e os autores observaram um deslocamento do foco da criação para atividades de verificação [1]. A descrição é precisa quanto ao que muda. O problema está no que ela sugere sobre o que permanece.
Revisar código gerado por agente não é uma versão passiva de programar. Exige um modelo mental do sistema que poucos engenheiros conseguem manter completo: entender se o endpoint gerado em segundos aplica as regras de autorização corretas, se valida entrada, se trata transações de banco adequadamente, se respeita as convenções da aplicação, se escala. Um agente pode produzir uma interface inteira em uma tarde; alguém precisa avaliar acessibilidade, gestão de estado, autenticação, desempenho e integração com os serviços de fundo. A supervisão é cognitivamente mais exigente do que a implementação, porque o supervisor precisa reconstruir decisões que não tomou.
A evidência mais perturbadora sobre esse deslocamento vem de um experimento controlado. Becker e colegas, do METR, conduziram um ensaio randomizado com 16 desenvolvedores experientes de projetos open-source, ao longo de 246 tarefas, comparando trabalho com e sem acesso a ferramentas de IA de início de 2025. O resultado foi que o acesso à IA aumentou o tempo de conclusão em 19% [6]. Mais revelador do que o número é a percepção: os mesmos desenvolvedores estimaram, ao final, terem sido cerca de 20% mais rápidos com a ferramenta [6]. Uma ressalva importante: em fevereiro de 2026, o próprio METR afirmou considerar provável que os desenvolvedores obtenham hoje mais ganho de velocidade com IA do que o estimado no início de 2025, ainda que com evidência fraca sobre o tamanho dessa melhora [10]. A desaceleração em si envelhece rápido; o descompasso entre percepção e medição, não.
Esse é o achado central da literatura recente, e ele não é sobre produtividade — é sobre calibração. Desenvolvedores experientes, trabalhando em seus próprios repositórios, com ferramentas de ponta, não conseguiram perceber que estavam mais lentos. Se a introspecção falha nesse grau em condições controladas, os relatórios de "ganho de 30% em produtividade" que circulam em apresentações executivas devem ser tratados como ficção auto-relatada até prova em contrário. Não porque os engenheiros mentem, mas porque o custo relevante — o tempo gasto lendo, corrigindo e reescrevendo saídas plausíveis e erradas — é invisível no fluxo da tarefa.
A posição que assumo aqui é desconfortável para os dois lados do debate. Contra os entusiastas: a transição para "engenharia supervisora" não é gratuita nem automática, e o pipeline que formava engenheiros capazes de supervisionar — anos escrevendo código ruim, depurando o próprio código ruim, construindo intuição sobre onde sistemas quebram — está sendo desmontado justamente quando se torna mais necessário. Contra os céticos: o experimento do METR mede tarefas de repositórios maduros e complexos, território onde o contexto tácito pesa muito; ele não demonstra que a IA não ajuda em código greenfield, em prototipagem ou em tarefas bem delimitadas. O que ele demonstra é que a intuição sobre o próprio desempenho não é evidência.
Por que testes passando não bastam
Um pipeline verde é a forma mais eficiente já inventada de produzir falsa segurança. Testes verificam o que foi especificado; não verificam o que foi omitido, nem o que foi especificado errado, nem o que o agente decidiu silenciosamente não fazer. Quando quem escreve o código também escreve os testes, e ambos derivam da mesma leitura incompleta do requisito, o pipeline confirma a coerência interna de um mal-entendido.
Os dados de Ehsani e colegas ajudam a dimensionar o fenômeno. O estudo analisou mais de 33 mil pull requests submetidos por cinco grandes agentes de código no GitHub e encontrou 71,48% de merges [4] — o que implica que quase 28,5% não entraram. A parte mais interessante do trabalho, contudo, é a taxonomia das falhas. Os autores enquadram as causas de rejeição em fatores sociotécnicos e de colaboração entre humanos e agentes — falta de engajamento dos revisores, PRs duplicados, implementação de funcionalidades não desejadas, desalinhamento do agente —, e não apenas em erros de sintaxe ou de lógica isolada [4]. Em outras palavras: o agente frequentemente produz código que funciona e que ainda assim não serve.
Funciona para quê, é a pergunta que os testes não respondem. Uma suíte verde pode conviver com um endpoint que autoriza o usuário errado porque o teste foi escrito a partir do mesmo pressuposto equivocado que o código. Pode conviver com uma migração de banco que passa em ambiente de teste com dez registros e trava em produção com dez milhões. Pode conviver com uma função que retorna o resultado correto por acidente, com complexidade quadrática que só se manifesta sob carga. A cobertura de testes mede execução de linhas, não verificação de comportamento; é uma métrica de esforço disfarçada de métrica de qualidade.
Existe uma classe de técnica subutilizada que ataca exatamente esse ponto: testes de mutação, que injetam defeitos artificiais no código e verificam se a suíte os detecta. Uma suíte que passa em todos os mutantes é uma suíte que não prova nada. Aplicada a código gerado por agente, a análise de mutação responde a uma pergunta que a cobertura não responde: os testes foram escritos para verificar o comportamento ou para acompanhar a implementação? A diferença é tudo. Testes que espelham a implementação — e agentes são notavelmente bons em produzir esse espelho — passam sempre e detectam nada.
A conclusão prática é que a verificação de código gerado precisa de oráculos independentes da geração. Especificações executáveis, propriedades invariantes, contratos de API verificados por consumidores reais, testes de integração escritos antes ou por outra pessoa, revisão humana focada em intenção e não em sintaxe. Sem independência de oráculo, o pipeline verde é apenas um espelho bem iluminado.
Arquitetura de verificação
Se o gargalo é a verificação, então a verificação precisa ser tratada como produto de engenharia, com dono, orçamento, SLOs e roadmap — e não como etapa residual do processo. É exatamente isso que o caso da Anthropic descreve, ainda que o artigo original não use esse vocabulário. Diante de um crescimento de 25 vezes no volume de jobs de CI em seis meses, a empresa não respondeu comprando mais máquinas em proporção linear; respondeu redesenhando a arquitetura de seleção de testes, para decidir quais validações eram necessárias para cada mudança em vez de executar o conjunto inteiro [7]. Trata-se de reconhecer que, quando o custo de validação por mudança não cai, o custo total cresce com o volume.
Uma arquitetura de verificação defensável tem camadas com funções distintas e custos distintos. Na base, verificações determinísticas e baratas que rodam em todo commit: análise estática, linting de segurança, verificação de dependências, detecção de segredos. Acima, seleção inteligente de testes por impacto, que mapeia mudanças a testes relevantes e reserva a suíte completa para integrações de risco. Depois, portões de revisão com escopo definido: um revisor humano que olha autorização e transações é mais útil do que três que olham formatação. No topo, validação em produção com exposição progressiva — canary, feature flags, telemetria de erro — porque algumas propriedades só se revelam sob tráfego real.
O ponto crítico, e o que a maioria das organizações ainda não fez, é o orçamento de revisão. Capacidade humana de revisão é um recurso finito e não elástico. Se um time consegue revisar com qualidade, digamos, 40 mudanças por semana, permitir que agentes abram 150 é criar uma fila cujo modo de falha natural é a aprovação superficial. O sistema não falha de forma ruidosa; falha silenciosamente, na forma de revisões cada vez mais rápidas e cada vez menos profundas, até que algo grave passa. Limitar a concorrência de agentes por revisor disponível não é burocracia — é controle de fluxo, o mesmo princípio que a manufatura aprendeu a aplicar há meio século.
Dois componentes merecem status próprio. O primeiro é proveniência: saber quais trechos de código foram gerados, por qual ferramenta, com qual prompt e sob qual revisão. Sem esse registro, a auditoria de segurança se torna arqueologia. O segundo é isolamento de execução: agentes que rodam testes, instalam dependências e executam scripts precisam fazê-lo em ambientes descartáveis, com credenciais de escopo mínimo. A superfície de ataque de um agente com acesso ao repositório e ao pipeline é considerável, e a literatura de segurança de código gerado raramente a discute.
Nada disso é barato. E aqui está a limitação honesta do argumento: construir essa arquitetura consome engenheiros exatamente do tipo que os agentes deveriam liberar. O investimento só se paga se o volume gerado for realmente aproveitável. Em organizações onde a maior parte do código produzido por agentes é descartada na revisão, a conta não fecha — e o problema não é a arquitetura de verificação, é a decisão anterior sobre o que delegar.
Novas métricas de produtividade
A DORA de 2025 oferece o retrato mais claro do descompasso entre percepção e confiança. Noventa por cento dos respondentes relataram usar IA no trabalho, e mais de 80% afirmaram acreditar em ganho de produtividade [12]. Ao mesmo tempo, 30% declararam pouca ou nenhuma confiança no código gerado por IA [12]. As duas coisas convivem sem contradição: usa-se porque todos usam, desconfia-se porque a experiência ensina.
Essa desconfiança difusa é um ativo. O problema é que ela não se converte em instrumento de gestão, porque as métricas disponíveis não a capturam. Praticamente todo dashboard de "adoção de IA na engenharia" mede atividade: número de sugestões aceitas, percentual de código gerado, sessões de agente, pull requests abertos. Nenhuma dessas medidas distingue contribuição de ruído. Pior: todas são maximizáveis por comportamentos que degradam o sistema, como aceitar sugestões sem ler ou fragmentar mudanças para inflar contagens.
Um conjunto de métricas voltado ao gargalo real teria outra composição. Latência de revisão, do primeiro commit à decisão, com acompanhamento de sua distribuição e não de sua média. Taxa de retrabalho, medida pelo percentual de código de agente modificado antes do merge — e aqui o dado de Watanabe é paradigmático: entre os PRs aceitos, 54,9% foram mesclados sem qualquer alteração, o que significa que 45,1% demandaram intervenção humana antes de entrar [2]. Taxa de defeitos escapados por mil mudanças, separada por origem do código. Custo de CI por mudança entregue. Tempo de restauração após incidente associado a mudanças geradas. E, sobretudo, uma medida de confiança calibrada: a divergência entre a avaliação do próprio time sobre a qualidade de uma entrega e o comportamento dessa entrega em produção.
A calibração é o ponto mais importante e o mais negligenciado. O experimento do METR é devastador precisamente porque mede a divergência: 19% mais lentos, com auto-percepção de 20% mais rápidos [6]. Nenhuma organização que coleta auto-relato de produtividade está medindo produtividade; está medindo moral. Isso não é inútil — moral importa, e a satisfação com a ferramenta tem efeitos reais de retenção — mas não pode ser confundido com desempenho. A recomendação prática é desconfortável para líderes: pare de perguntar aos times se a IA os deixou mais rápidos e comece a medir, com dados de sistema, quanto tempo cada mudança leva do commit à produção e quanto retrabalho ela gera no caminho.
Recomendações para líderes
O primeiro movimento não é técnico, é orçamentário. Toda organização que escala agentes de código deve escalar, na mesma decisão, a capacidade de verificação: infraestrutura de CI, ferramentas de análise, tempo protegido de revisão e pessoas capazes de revisar com profundidade. Tratar essas duas decisões como separadas — acelerar a produção e "ver depois" como se verificação fosse gratuita — é a causa raiz do padrão descrito ao longo deste artigo. O crescimento de 25 vezes em CI relatado pela Anthropic é o que acontece quando essa conta chega [7].
O segundo é limitar a concorrência pelo recurso escasso. Definir um teto de mudanças simultâneas por revisor disponível, com fila explícita, é mais saudável do que permitir que agentes abram trabalho em paralelo e deixar que a revisão se degrade para absorver. Filas visíveis geram pressão para melhorar o processo. Filas invisíveis geram aprovações de fachada.
O terceiro é redefinir o escopo da revisão humana. Revisores não devem gastar atenção em formatação, estilo ou padrões que ferramentas determinísticas resolvem. Devem gastar em decisões irreversíveis e caras: modelo de dados, fronteiras de autorização, transações, contratos de API, escolhas arquiteturais, dependências externas. Uma política de revisão que trate o código do agente como código de terceiro não confiável — porque é isso que ele é — produz melhores resultados do que uma política que o trate como rascunho de um colega.
O quarto é investir na formação do supervisor. Se o valor do engenheiro sênior se desloca para o julgamento, e o julgamento se forma escrevendo e depurando código, então reduzir a exposição de profissionais juniores à implementação direta é uma aposta de curto prazo com custo de longo prazo. Programas de formação precisam preservar deliberadamente o trabalho difícil que constrói intuição: depuração de sistemas reais, leitura de código alheio, diagnóstico de incidentes.
O quinto é tratar a segurança do código gerado como risco de processo, não como risco de ferramenta. O achado de Kharma e colegas de que nenhum dos métodos de prompting testados reduziu de forma estatisticamente significativa as vulnerabilidades [5] implica que a defesa não pode ficar só na entrada: templates de prompt não substituem checklists obrigatórios, análise automatizada e revisão reforçada para superfícies sensíveis. E implica que homologar um modelo não resolve nada.
O sexto, e talvez o mais importante, é aceitar que parte do ganho prometido não existe. O estudo do METR com 16 desenvolvedores experientes em 246 tarefas encontrou desaceleração de 19% [6]. Mesmo o agente mais consistente do estudo de Pinna e colegas, o OpenAI Codex, oscila entre 59,6% e 88,6% de aceitação conforme o tipo de tarefa [3]. A documentação é aceita com 82,1% de frequência, contra 66,1% em novas funcionalidades [3]. Esses dados não dizem que a tecnologia é inútil; dizem que seu retorno é altamente condicional. Líderes que prometem ganhos uniformes estão prometendo algo que a evidência não sustenta.
Conclusão
A tese deste artigo pode ser resumida em uma frase: a adoção de agentes de código não elimina trabalho de engenharia, ela o realoca para a verificação, e as organizações que não realocarem recursos na mesma proporção colherão filas em vez de velocidade. Os dados disponíveis sustentam essa leitura em três frentes. Na infraestrutura, o crescimento de 25 vezes em jobs de CI em seis meses mostra que a validação é o novo limitante [7]. Na qualidade do que se produz, o fato de que 45,1% dos PRs aceitos precisaram de ajuste humano — e de que só cerca de 46% do total entrou intacto — mostra que boa parte do que os agentes entregam exige intervenção [2]. Na percepção, a divergência do METR entre 19% de desaceleração real e 20% de aceleração percebida mostra que os times não conseguem avaliar seu próprio desempenho nesse regime [6].
Três direções futuras merecem atenção prioritária. A primeira é tratar a verificação como produto: plataformas internas de validação, com seleção de testes por impacto, análise de mutação, oráculos independentes e proveniência de código, têm potencial de retorno maior do que mais uma licença de agente. A segunda é fechar a lacuna empírica. A literatura atual se apoia fortemente em repositórios públicos de projetos open-source, com mantenedores experientes e contexto compartilhado — território favorável à IA. Faltam estudos longitudinais em ambientes corporativos, com código proprietário, prazos e hierarquia, medindo defeitos escapados e não apenas taxas de aceitação. A terceira é a formação de gente capaz de supervisionar. Se o gargalo é julgamento, e o julgamento se constrói em anos de trabalho técnico direto, a decisão de reduzir a exposição de juniores à implementação é uma decisão sobre a capacidade de verificação da próxima década.
Nada disso autoriza o ceticismo fácil. Os agentes funcionam, e funcionam melhor a cada ciclo — as taxas de aceitação do OpenAI Codex, entre 59,6% e 88,6% nas nove categorias de tarefa, não são um fenômeno marginal [3]. O que a evidência não autoriza é a conclusão de que produzir mais código seja o objetivo. A engenharia de software nunca teve como problema principal a quantidade de texto que consegue emitir. Teve como problema garantir que o sistema faça o que deve, sem fazer o que não deve. Nenhuma ferramenta que acelere a emissão de texto resolve esse problema. Algumas apenas o tornam mais urgente.
Referências
- [1] Vella, A.; Blincoe, K. (2026). The Impact of AI Coding Assistants on Software Engineering: A Longitudinal Study. arXiv:2605.23135. https://arxiv.org/abs/2605.23135
- [2] Watanabe, M.; Li, H.; Kashiwa, Y.; Reid, B.; Iida, H.; Hassan, A. E. (2025). On the Use of Agentic Coding: An Empirical Study of Pull Requests on GitHub. arXiv:2509.14745. https://arxiv.org/abs/2509.14745
- [3] Pinna, G.; Gong, J.; Williams, D.; Sarro, F. (2026). Comparing AI Coding Agents: A Task-Stratified Analysis of Pull Request Acceptance. MSR '26 / arXiv:2602.08915. https://arxiv.org/abs/2602.08915
- [4] Ehsani, R.; Pathak, S.; Rawal, S. et al. (2026). Where Do AI Coding Agents Fail? An Empirical Study of Failed Agentic Pull Requests in GitHub. MSR '26 / arXiv:2601.15195. https://arxiv.org/abs/2601.15195
- [5] Kharma, M.; Sabbah, A.; Alkhanafseh, M.; Hammoudeh, M.; Mohaisen, D. (2026). An Empirical Evaluation of LLM-Generated Code Security Across Prompting Methods. arXiv:2605.24298. https://arxiv.org/abs/2605.24298
- [6] Becker, J.; Rush, N.; Barnes, E.; Rein, D. (2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. METR / arXiv:2507.09089. https://arxiv.org/abs/2507.09089
- [7] Anthropic (2026). Agentic coding is straining CI: how we scaled test impact analysis. 14 de setembro de 2026. https://claude.com/blog/agentic-coding-is-straining-ci-heres-how-we-scaled-test-impact-analysis-at-anthropic
- [8] DORA / Google Cloud (2025). State of AI-assisted Software Development 2025. https://dora.dev/dora-report-2025/
- [9] Endor Labs (2026). The Most Common Security Vulnerabilities in AI-Generated Code. https://www.endorlabs.com/learn/the-most-common-security-vulnerabilities-in-ai-generated-code
- [10] METR (2026). We are Changing our Developer Productivity Experiment Design. 24 de fevereiro de 2026. https://metr.org/blog/2026-02-24-uplift-update/
- [11] Axios (2026). AI bug reports are overwhelming OpenSSL security maintainers. 20 de outubro de 2026. https://www.axios.com/2026/10/20/ai-bug-reports-overwhelm-openssl-maintainers
- [12] Google Cloud (2025). Announcing the 2025 DORA Report. 23 de setembro de 2025. https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report