O Muro dos 10%: Por que a Produtividade com IA Estagna e o que Rompe essa Barreira

A DX pesquisou 121.000 desenvolvedores em 450 empresas. 92,6% usam assistentes de codificação com IA pelo menos mensalmente. Código gerado por IA agora representa 26,9% dos merges em produção. Desenvolvedores relatam economizar aproximadamente quatro horas por semana.¹ A produtividade não passou de 10%.

Esse número se manteve estável por três trimestres consecutivos.^{1 2} A adoção cresceu. O volume de código cresceu. As ferramentas melhoraram. Os ganhos não. Laura Tacho, CTO da DX, enquadrou a questão diretamente: “Isso é realmente um problema de gestão. O hype fez parecer que simplesmente experimentar IA traria retorno automático.”³

O Relatório DORA 2025 encontrou a divergência. Organizações com práticas de engenharia sólidas viram a IA amplificar suas forças existentes. Organizações com práticas frágeis viram a IA amplificar suas disfunções existentes. Mesmas ferramentas. Resultados opostos. O relatório concluiu: “O papel principal da IA no desenvolvimento de software é o de amplificador. Ela magnifica as forças de organizações de alto desempenho e as disfunções das que estão em dificuldade.”⁴

O muro não é um problema de modelo. É um problema de infraestrutura. Modelos melhores não vão romper um muro construído com verificação ausente, contexto ausente e governança ausente. Os posts complementares a este descrevem a arquitetura: Anatomy of a Claw explica a camada de orquestração, The Fabrication Firewall explica o portão de saída, e Context Is Architecture explica o sistema de injeção de contexto. Este post explica por que esses sistemas existem.

Resumo

121.000 desenvolvedores pesquisados. 92,6% de adoção. Produtividade estagnada em 10%. O muro existe porque a IA gera código mais rápido do que as organizações conseguem verificar, contextualizar ou governar. Três causas raiz: privação de contexto (a IA alucina sem conhecimento específico do projeto), vácuo de verificação (o código é entregue mais rápido do que os processos de revisão se adaptam), e lacuna de governança (a IA contorna padrões de qualidade que humanos aplicam). Romper a barreira exige infraestrutura ao redor da IA, não uma IA melhor. A evidência: organizações que construíram infraestrutura de verificação e governança reduziram incidentes pela metade; organizações que adotaram IA sem infraestrutura dobraram os seus.^{4 5} Esta é uma tentativa N=1 de construir essa infraestrutura, documentada com números específicos. Não pode provar generalizabilidade. Pode demonstrar como é o outro lado do muro.

O que a pesquisa diz

O conjunto de dados da DX abrange 4,2 milhões de desenvolvedores observados entre novembro de 2025 e fevereiro de 2026, com um painel detalhado de 121.000 desenvolvedores em 450 empresas.¹ Os números contam duas histórias.

A história da adoção é inequívoca. Assistentes de codificação com IA atingiram penetração quase universal. A DX mediu 92,6% de adoção mensal e aproximadamente 75% de uso semanal.¹ A pesquisa do Stack Overflow de 2025 encontrou que 84% dos desenvolvedores usam ou planejam usar ferramentas de IA.⁶ A JetBrains mediu 85% de uso regular entre 24.534 desenvolvedores em 194 países.⁷ O teto de adoção está próximo.

A história da produtividade estagnou. A DX mediu uma média de quatro horas economizadas por semana, sem mudança em relação às 3,6 horas do trimestre anterior.^{1 2} Código gerado por IA subiu de 22% para 26,9% do código mergeado, mas o volume adicional não se traduziu em produção adicional.^{1 2} Laura Tacho identificou a matemática: desenvolvedores passam aproximadamente 20% do seu tempo escrevendo código. Uma melhoria de 10% em 20% do dia de trabalho é uma melhoria de 2% no geral. “Velocidade de digitação nunca foi o gargalo.”⁸

A linha crítica é a última. O relatório DORA de 2024 pesquisou 39.000 profissionais e descobriu que para cada 25% de aumento na adoção de IA, o throughput de entrega diminuiu estimadamente 1,5% e a estabilidade de entrega diminuiu 7,2%.⁵ O relatório DORA de 2025 constatou que o throughput se recuperou (a relação inverteu de negativa para positiva), mas a estabilidade permaneceu negativa.⁴ A adoção de IA continuou a se correlacionar com aumento de instabilidade mesmo com a melhoria do throughput.

A divergência importa mais do que as médias. O METR estudou 16 desenvolvedores experientes de código aberto trabalhando em 246 issues reais de repositórios e descobriu que levaram 19% mais tempo com ferramentas de IA do que sem.⁹ O ensaio controlado randomizado do Google com 96 engenheiros encontrou uma melhoria de velocidade de 21%, mas o resultado não foi estatisticamente significativo (IC 95% cruzou o zero).¹⁰ A McKinsey encontrou ganhos de 35-50% em tarefas simples, mas menos de 10% em tarefas de alta complexidade.¹¹ O padrão: a IA acelera as partes do desenvolvimento que nunca foram o gargalo.

As empresas que romperam a barreira não usaram modelos melhores. Construíram infraestrutura que capturou o que os modelos deixaram passar.

Por que o muro existe

Três causas raiz explicam o platô. Cada uma opera independentemente. Juntas formam um teto que modelos melhores não conseguem penetrar.

Privação de contexto

Assistentes de codificação com IA operam sobre o código visível no arquivo atual e qualquer contexto que caiba na janela do prompt. Eles não conhecem suas decisões de arquitetura, seus contratos de API, suas restrições de deploy, ou as convenções de nomenclatura da sua equipe, a menos que alguém injete essas informações.

Sem contexto específico do projeto, o modelo adivinha. Ele alucina caminhos de arquivo que seguem convenções plausíveis mas não existem. Gera chamadas de API para endpoints que correspondem a padrões comuns, mas não aos seus padrões. Sugere imports de pacotes que seu projeto não usa.¹²

A Faros AI analisou telemetria de 10.000 desenvolvedores em 1.255 equipes e descobriu que pull requests assistidos por IA são 154% maiores do que os não assistidos.¹² PRs maiores carregam mais área de superfície para erros dependentes de contexto. A IA gera código com confiança. O código compila. O código não leva em conta a restrição documentada em uma página do Confluence que a IA nunca viu.

Isso não é um problema de alucinação no sentido de segurança do modelo. O modelo está funcionando exatamente como projetado: prevendo código provável dado o contexto disponível. O problema é que o contexto disponível exclui a maior parte do que importa para a correção em uma base de código específica.

Vácuo de verificação

A IA gera código mais rápido do que os processos de revisão existentes conseguem absorver. A Faros descobriu que PRs assistidos por IA levam 91% mais tempo para revisar.¹² Desenvolvedores completam 21% mais tarefas e fazem merge de 98% mais pull requests, mas o pipeline de revisão lida com produção em velocidade humana.¹²

O estudo de código inseguro de Stanford quantificou a dimensão de segurança. Pesquisadores deram a 47 desenvolvedores tarefas de codificação com e sem assistência de IA. O grupo assistido por IA escreveu soluções inseguras com mais frequência em quatro de cinco tarefas. Na tarefa de SQL injection, 36% do grupo com IA escreveu código vulnerável versus 7% do grupo de controle. Participantes com assistência de IA tinham mais probabilidade de acreditar que escreveram código seguro mesmo quando não tinham.¹³ A combinação de produção mais rápida e falsa confiança mais alta cria uma lacuna de verificação que a revisão manual não consegue fechar em escala.

A GitClear analisou 153 milhões de linhas de código alteradas e descobriu que o code churn (código reescrito dentro de duas semanas após ser escrito) projetava dobrar em 2024 em relação aos baselines pré-IA.¹⁴ O aumento de volume das ferramentas de IA cria retrabalho que compensa parcialmente os ganhos de produtividade. A pesquisa do Stack Overflow de 2025 confirma o atrito: 66% dos desenvolvedores relatam gastar mais tempo corrigindo código gerado por IA que está “quase certo”.⁶

Lacuna de governança

Código gerado por IA contorna os mecanismos de governança que desenvolvedores humanos internalizam. Um desenvolvedor sênior sabe verificar o guia de estilo, executar o linter, atualizar o changelog e notificar o líder técnico sobre mudanças de arquitetura. Um assistente de IA gera uma solução que satisfaz o prompt. A distância entre “compila e passa nos testes” e “atende aos padrões organizacionais” é governança.

O estudo da McKinsey de 2023 descobriu que desenvolvedores juniores usando IA foram 7-10% mais lentos, não mais rápidos.¹¹ Os pesquisadores atribuíram isso à distância entre o código gerado e o contexto organizacional. Desenvolvedores juniores não possuem o julgamento para avaliar se a saída da IA atende a padrões que ainda não internalizaram. Sem infraestrutura de governança que codifique esses padrões como verificações automatizadas, a saída da IA flui sem checagem.

A lacuna de governança se acumula entre equipes. O utilitário gerado por IA de um desenvolvedor duplica o módulo existente de outro. Dois endpoints gerados por IA usam formatos de erro diferentes para a mesma API. Migrations geradas por IA seguem uma convenção de nomenclatura diferente do padrão da equipe. Cada violação é pequena. O efeito acumulativo é uma base de código que diverge de suas próprias convenções mais rápido do que a revisão consegue corrigir.

Como é o outro lado

A descoberta do DORA descreve duas populações usando ferramentas idênticas. Uma reduziu incidentes pela metade. A outra dobrou.⁴ A variável entre elas não é qual IA usam. É a infraestrutura ao redor da IA.

Cada causa raiz corresponde a uma correção de infraestrutura. A tabela abaixo mapeia a cadeia do problema à solução, com uma implementação concreta de um sistema que construí e documentei nos posts complementares. Esta é uma tentativa com números específicos, não uma prescrição universal.

Injeção de contexto aborda a privação garantindo que o modelo receba informações específicas do projeto em cada prompt. Um hook dispatcher dispara nove handlers sequenciais que injetam a data atual, branch do Git, diretório de trabalho, convenções do projeto, contexto da tarefa ativa e restrições arquiteturais. O modelo recebe 200-400 tokens de contexto de ancoragem antes de processar a requisição do usuário. Latência medida: 200ms no total para todos os nove hooks. O modelo para de adivinhar caminhos de arquivo porque recebeu os caminhos reais.¹⁵

Verificação independente aborda o vácuo removendo humanos do gargalo de verificação em checagens rotineiras. O loop de desenvolvimento autônomo (documentado em Anatomy of a Claw) gera código, executa a suíte completa de testes e submete os resultados a três agentes de revisão que operam independentemente. O agente de implementação nunca revisa sua própria saída. Isso espelha a descoberta de que o grupo assistido por IA no estudo de Stanford estava mais confiante em código inseguro: autoverificação é não confiável, seja o autor humano ou artificial.¹³

Governança automatizada aborda a lacuna codificando padrões da equipe como verificações executáveis. O Fabrication Firewall classifica cada ação de saída como local, compartilhada ou externa, delegando publicação externa para revisão humana. Portões de qualidade bloqueiam relatórios de conclusão que usam linguagem evasiva (“deveria funcionar”, “parece correto”) em vez de citar saída de testes e caminhos de arquivo. O sistema aplica padrões que desenvolvedores humanos aplicariam se tivessem tempo de revisar cada linha. Na velocidade de geração da IA, eles não têm.

O sistema combinado produz resultados mensuráveis em sua própria base de código: 4.518 chunks de código indexados para busca semântica, 49.746 chunks de vault em 15.800 arquivos para memória persistente, e uma suíte de testes que executa automaticamente antes de qualquer mudança reportar conclusão.¹⁵ Esses números descrevem a infraestrutura de um desenvolvedor. Não podem provar que a abordagem generaliza. Podem demonstrar que o muro é permeável com as ferramentas certas do outro lado.

A proporção de governança

O sistema de hooks descrito em Anatomy of a Claw contém 84 hooks. Uma contagem verificada os separa por função: 35 hooks de julgamento que decidem se algo deve acontecer, e 44 hooks de automação que executam ações predeterminadas. A proporção é 4:5. Começou em 1:6.¹⁵

A proporção inicial reflete o que a maioria das equipes constrói primeiro: automação. Injetar contexto. Registrar métricas. Formatar saída. Registrar uso. Esses hooks capturam os 10% que todos obtêm. Eles automatizam as partes mecânicas do desenvolvimento que já eram parcialmente automatizadas antes da IA. Os dados da DX confirmam: as quatro horas economizadas por semana vêm da geração de código e redução de boilerplate, tarefas que já eram a parte mais rápida do ciclo de desenvolvimento.¹

A mudança em direção a hooks de julgamento reflete de onde vêm os ganhos adicionais.

A pesquisa da McKinsey de 2025 com quase 300 empresas descobriu que os melhores desempenhos viram melhorias de produtividade de 16-30% e melhorias de qualidade de 31-45%.¹⁶ Essas organizações tinham 80-100% de adoção por desenvolvedores combinada com integração organizacional. O fator diferenciador não era a taxa de adoção (que se correlaciona com ganhos de 10% em geral), mas a infraestrutura e os processos construídos ao redor dessa adoção.

O enquadramento de Laura Tacho se aplica aqui: “Sou cética quanto à promessa de qualquer tecnologia de melhorar o desempenho sem abordar essas restrições subjacentes.”³ As restrições subjacentes são restrições de julgamento. Este código atende aos nossos padrões? Esta mudança quebra algo downstream? Esta saída contém uma fabricação? Hooks de automação não conseguem responder a essas perguntas. Hooks de julgamento conseguem, imperfeitamente, codificando os critérios que desenvolvedores experientes aplicam mentalmente.

A proporção ainda não atingiu paridade. O sistema ainda automatiza mais do que governa. Isso é em si um diagnóstico: qualquer camada de orquestração onde hooks de automação superam hooks de julgamento tem espaço para melhorar.

O que você realmente precisa construir

O sistema descrito nos posts complementares tem 84 hooks, 43 skills, 19 agentes e 15.000 linhas de infraestrutura. Você não precisa de 15.000 linhas. Você precisa de três coisas.

Um hook de injeção de contexto. Cinco linhas de bash que injetam a data atual, branch e diretório de trabalho em cada prompt de IA. Isso elimina uma categoria inteira de alucinação: o modelo para de inventar caminhos de arquivo e nomes de branch porque tem os reais.

#!/bin/bash
# inject-context.sh — minimum viable context injection
echo "Date: $(date +%Y-%m-%d)"
echo "Branch: $(git branch --show-current 2>/dev/null || echo 'not a git repo')"
echo "Directory: $(pwd)"

Um portão de qualidade. Quinze linhas que fazem grep em relatórios de conclusão procurando linguagem evasiva. Se o agente diz “deveria funcionar” em vez de citar saída de testes, o portão bloqueia. Isso aborda o vácuo de verificação no ponto de entrada mais barato possível.¹⁵

#!/bin/bash
# quality-gate.sh — minimum viable verification
INPUT=$(cat)
HEDGES=$(echo "$INPUT" | grep -ciE '\bshould (work|pass|be fine)\b|\bprobably\b|\blooks correct\b')
if [ "$HEDGES" -gt 0 ]; then
  echo '{"decision":"block","reason":"Hedging language detected. Cite test output instead."}'
else
  echo '{"decision":"allow"}'
fi

Um test runner independente. Um hook que executa a suíte de testes do projeto após cada mudança de código e falha ruidosamente se os testes quebrarem. A implementação varia por projeto. O princípio não: o agente que escreve código não deve ser o único juiz desse código.

Comece com o que mais quebra no seu workflow. Se sua IA alucina caminhos de arquivo, construa o hook de contexto primeiro. Se sua IA entrega código não testado, construa o test runner primeiro. Se sua IA escreve “pronto” sem evidência, construa o portão de qualidade primeiro.

Karpathy descreveu a evolução de vibe coding para engenharia agêntica: “orquestrar agentes que fazem [o trabalho] e atuar como supervisão.”¹⁷ Os três hooks acima são a supervisão mínima viável. Eles não vão produzir ganhos de 30%. Vão mover você de 10% para 15%, e cada um que você adicionar revela a próxima restrição que vale a pena abordar.

O muro é real. Também é específico. Privação de contexto, vácuo de verificação e lacuna de governança são problemas de engenharia com soluções de engenharia. Os modelos vão continuar melhorando. O muro vai continuar em 10% para cada equipe que trata a IA como um gerador de código em vez de um sistema que requer infraestrutura para governar sua saída.

Fontes