Quando a IA Escreve 80% do Seu Código, o CI Vira o Gargalo
Por dois anos, o debate sobre codificação com IA girou em torno de uma pergunta que já não importa mais: a IA vai substituir os programadores? Em 14 de setembro de 2026, a Anthropic publicou material que invalida silenciosamente essa premissa. Seus engenheiros agora entregam, em média, 8 vezes mais código por trimestre do que entregavam de 2021 a 2025, e mais de 80% do código mesclado na base da empresa é escrito pelo Claude. Escrever código não é mais a restrição. Revisar código também não é mais a restrição — um revisor automatizado do Claude agora lê toda mudança proposta.
A primeira coisa que realmente quebrou foi o sistema de CI. Os casos de teste na base da Anthropic cresceram 10x, e o volume de jobs de integração contínua (CI) explodiu 25x em seis meses.
A tese deste artigo é simples: o verdadeiro gargalo no desenvolvimento de software com IA migrou da geração de código para a sua verificação e entrega. Quando a capacidade de produção cresce exponencialmente, cada peça de infraestrutura de engenharia desenhada em torno de um ritmo humano se torna o campo de batalha.
Por Que o CI Caiu Primeiro
Os detalhes do incidente de CI da Anthropic são mais informativos do que qualquer reivindicação de produtividade. A empresa roda um serviço de análise de impacto de testes — um sistema determinístico que decide quais testes rodar em cada pull request (PR). Dois componentes o mantêm funcionando: um “listener” registra os resultados dos testes de cada execução de CI, e um “selector” lê esse histórico para decidir o que rodar nos PRs recém-abertos. A arquitetura funcionava bem na era humana. Ela se apoiava em uma suposição fatal: os commits são esparsos, e há janelas de horário de baixa demanda para colocar as coisas em dia.
A IA destruiu essa suposição de três maneiras ao mesmo tempo.
Primeiro, os PRs ficaram menores. O Claude prefere PRs menores e mais granulares — uma pequena mudança por PR —, então a frequência de gatilhos do pipeline cresceu geometricamente. Segundo, a janela de baixa demanda desapareceu. Os agentes não dormem. Eles enviam código, executam tarefas e refatoram durante a noite e nos fins de semana, apagando a folga noturna que costumava absorver o acúmulo de pendências. Terceiro, os testes explodiram. Junto de cada mudança de lógica, o Claude escreve testes unitários e de integração densos; a suíte de testes da base cresceu 10x.
O resultado combinado: quando o listener de processo único ficou apenas 20 minutos atrasado, dezenas de milhares de atualizações de testes nunca chegaram ao selector. Mudanças ruins foram mescladas, e engenheiros de toda a empresa começaram a investigar falhas que não tinham nada a ver com eles. Testes instáveis passaram a bloquear mesclagens. Testes recém-corrigidos ficavam invisíveis, e regressões se espalhavam.
Em um mundo onde o código é escrito instantaneamente, a verificação entra em fila.
Três Patches, Cada Um Mais Curto que o Anterior
A análise retrospectiva do engenheiro Sachin Malhotra se lê como um estudo de caso sobre a decadência dos patches.
Patch 1: uma máquina maior. A equipe dobrou os núcleos que rodavam o serviço. Todos sabiam que era temporário; ninguém esperava que durasse apenas 70 dias.
Patch 2: sharding. Em vez de um único escritor global, cada pacote ganhou seu próprio shard worker com seu próprio escritor — código que o próprio Claude gerou. Isso rendeu 29 dias.
Patch 3: reinicializações diárias. Em março de 2026, o serviço batia seu limite de memória no meio da tarde na maioria dos dias úteis. A equipe encontrou apenas quatro bugs, trocar o alocador de memória não resolveu nada, e ninguém ousava rodar profiling de memória em um singleton sob carga pesada. Então agendaram reinicializações automáticas diárias. Sob a concorrência implacável da IA, o truque da reinicialização durou menos de um dia; o listener repetidamente ficava mais de uma hora atrasado, e o selector escolhia testes com base em dados desatualizados.
Setenta dias, 29 dias, menos de um dia. A vida útil dos patches entrou em colapso exponencial — esse é o verdadeiro ritmo da era da IA. Como colocou Malhotra, cada técnica clássica de escalonamento agora rende uma fração do tempo que rendia há um ano, enquanto um redesenho completo leva uma fração do tempo que levava.
A correção final foi a que o Claude vinha defendendo há meses: demolir todo o singleton. A equipe deu ao serviço de seleção de testes um armazenamento de dados em memória. Qualquer worker listener agora pode processar qualquer resultado, anexá-lo a um journal e seguir em frente sem manter nada em memória — stateless e, portanto, escalável horizontalmente. Um pequeno processo consumidor consolida o journal em histórico por teste a cada poucos segundos, e o selector o lê instantaneamente. Após a migração, uma fila de pendências que vinha se acumulando em centenas de milhares de eventos foi zerada. Um engenheiro construiu isso em três semanas; há um ano, teria levado um trimestre. Escrever código não é mais caro. Decidir se vale a pena reescrever é que virou.
Um Framework: A Largura de Banda de Verificação É o Novo Throughput
Abstraindo o incidente em uma ferramenta reutilizável: o throughput de um sistema de entrega não é definido pela sua etapa mais rápida, mas pela sua largura de banda de verificação — a rapidez com que os testes dão retorno, a confiabilidade com que os resultados fluem e a velocidade com que as falhas são localizadas.
Na era humana, escrever código era a etapa mais lenta, então a largura de banda de verificação estava sempre em excedente e ninguém a tratava como um recurso. A IA levou o custo de geração a quase zero, e a largura de banda de verificação se tornou a restrição dura: escassa, incomprimível e, ao contrário do código, incapaz de crescer exponencialmente. O erro central da Anthropic foi expandir a capacidade linearmente contra um crescimento exponencial. O conselho de Malhotra é direto: assuma que sua arquitetura enfrentará uma carga 25x maior em dois trimestres, e projete sistemas v0 para 10–20x a escala atual percebida.
O framework viaja bem. Um suporte ao cliente com IA que acelere a geração de tickets em 10x vai sobrecarregar primeiro a fila humana de revisão de qualidade. Imagem médica com assistência de IA satura primeiro o loop de confirmação do patologista. Textos de marketing gerados por IA sobrecarregam primeiro o processo de revisão de marca. O padrão é consistente: qualquer que seja a etapa que a IA acelere, a etapa de verificação a jusante dela entra em sobrecarga primeiro.
O Quadro Maior: O Primeiro Campo da RSI
Este incidente não é uma história de guerra isolada. Lido junto com o relatório da Anthropic “When AI Builds Itself”, publicado na mesma semana, ele se torna um único sinal estrutural. Esse relatório revela: nas tarefas mais abertas, a taxa de sucesso do Claude subiu de cerca de 26% para 76% em seis meses; em abril de 2026, o Claude entregou mais de 800 correções que reduziram uma classe de erros de API em um fator de mil — trabalho que o engenheiro supervisor estimou que levaria quatro anos para um humano; em uma tarefa de otimização experimental com objetivo fixo, o Claude passou de cerca de 3x de aceleração em maio de 2025 para cerca de 52x em abril de 2026, enquanto um pesquisador humano habilidoso alcança apenas 4x em quatro a oito horas na mesma tarefa.
Mais dois números merecem destaque próprio. Primeiro, uma retrospectiva descobriu que a revisão automatizada do Claude teria detectado cerca de um terço dos bugs por trás de incidentes passados de produção do claude.ai — bugs escritos por alguns dos melhores engenheiros de sistemas do mundo. Segundo, o GitHub recebeu cerca de um bilhão de commits em todo o ano de 2025; em meados de 2026, já registrava 275 milhões por semana, em ritmo de cerca de 14 bilhões por ano. A indústria inteira está absorvendo o choque de capacidade da IA.
Um experimento captura a direção do movimento: em um problema de supervisão fraco-para-forte, dois pesquisadores humanos recuperaram cerca de 23% de uma lacuna de desempenho mensurável ao longo de uma semana, enquanto agentes do Claude recuperaram 97% em 800 horas acumuladas e cerca de US$ 18.000 em computação. Os humanos escolheram a direção; os agentes desenharam cada experimento. Essa é a versão micro do incidente de CI — os humanos recuam para decidir se vale reescrever, e a IA cuida do como.
A Anthropic chama isso de estágio precursor da autoaperfeiçoamento recursivo (RSI) e faz um apelo público incomum: se a tendência superar a pesquisa de segurança e a governança, laboratórios de fronteira em vários países precisarão de um mecanismo coordenado para desacelerar. O relatório é franco ao admitir que a verificação é a parte difícil — execuções de treinamento são muito mais fáceis de esconder do que silos de mísseis, e regimes de controle de armamentos levaram décadas para ser construídos. Nós não temos décadas.
O Que Fazer a Respeito
Se você lidera uma organização de engenharia:
- Planeje capacidade para uma carga 25x maior em dois trimestres, e projete sistemas v0 com folga de 10–20x sobre a escala atual percebida.
- Mantenha o estado fora do processo desde o primeiro dia, e se recuse a rodar qualquer serviço crítico como instância única.
- Instrumente tudo — dê aos agentes a telemetria para progredirem por conta própria, e garanta que os jobs de CI que entram sejam iguais aos que saem.
Se você é um engenheiro individual:
- Seu valor está migrando de escrever código para definir o que vale a pena escrever e julgar se os resultados da verificação são confiáveis. Assuma a direção estratégica que a IA ainda faz mal.
- Audite as suposições implícitas de ritmo humano da sua equipe — janelas de baixa demanda, processamento em lote, filas manuais. Cada uma delas é um futuro atraso de listener.
Se você gere plataforma ou infraestrutura:
- A largura de banda de verificação é o seu principal KPI para o próximo ano. Meça o teto atual, multiplique por 25, e esse é a sua demanda em seis meses.
- Seleção de testes escalável horizontalmente está saindo de especialidade de empresas pesadas para se tornar um padrão da indústria.
O código pode dobrar da noite para o dia. A capacidade de entrega precisa acompanhar. Enquanto todos competem na velocidade com que sua IA escreve código, a verdadeira separação estará em quem tem sistemas capazes de absorvê-lo.
