O software está quebrando. E a culpa não é (só) sua.
Eu vou ser direto: o software que roda o mundo está pior do que era dois anos atrás. Não é feeling, não é saudosismo de quem gosta de reclamar. São números. Dados de 623 milhões de commits analisados pela GitClear mostram que a qualidade do código caiu em praticamente toda métrica que importa desde que ferramentas de IA viraram padrão no fluxo de desenvolvimento.
E o mais perturbador? A maioria dos times nem percebeu. Estão celebrando a velocidade enquanto o prédio racha por dentro.
Um artigo do engenheiro Breck McKye que explodiu no Hacker News esta semana coloca de forma crua: o software está quebrando em nível sistêmico. Não é um bug aqui, um incidente ali. É a estrutura inteira de como construímos software que está cedendo.
Eu concordo. E os dados confirmam.
70% mais bugs: os números que ninguém quer ver
Vamos começar pelo que dói. Segundo o relatório AI Code Quality 2026, código gerado por IA carrega 70% mais bugs do que código escrito por humanos. Erros de lógica são 1,75x mais comuns. Problemas de manutenibilidade, 1,64x.
E a confiança dos desenvolvedores? Despencou para 33%. Ou seja: 84% dos devs usam ferramentas de IA no dia a dia, mas apenas um terço confia no que elas produzem. Estamos num ciclo absurdo onde todo mundo usa algo que quase ninguém confia.
O Cortex 2026 Benchmark Report, que entrevistou mais de 50 líderes de engenharia, trouxe outro dado brutal: o change failure rate (percentual de deploys que causam outages ou rollbacks) subiu 30%. PRs por autor subiram 20%. Incidentes por PR saltaram 23,5%.
Traduzindo: estamos fazendo deploy mais rápido de código que quebra mais. Parabéns, atingimos a velocidade terminal da mediocridade.
A ilusão da produtividade
“Mas meu time está entregando 4x mais!” Sim, provavelmente está. A GitClear confirma que usuários pesados de IA produzem de 4 a 10x mais código. Mas quando comparam esses mesmos devs com seu próprio output anterior, o ganho real de velocidade é de 25%. O resto é volume.
E que volume é esse? Código duplicado. A pesquisa mostra que duplicação de blocos de código subiu 81% desde 2023 (de 40,3 para 73,0 por milhão de linhas alteradas). Copy/paste dentro do mesmo commit subiu 41%. Construções que mascaram erros, 47%.
Enquanto isso, refactoring desabou. Atividade de refatoração caiu para 3,8% das linhas alteradas, contra 21% em 2022. Chamadas cross-file (indicativo de reuso) caíram 35%. Manutenção de código legado caiu 74%.
Leia esses números de novo. O refactoring caiu de 21% para 3,8%. Isso não é um declínio, é uma extinção. Estamos gerando código numa velocidade absurda e nunca paramos para limpar nada.
| Métrica | 2022/2023 | 2026 | Variação | |
|---|---|---|---|---|
| ——— | ———– | —— | ———- | |
| Refactoring (% das linhas) | 21% | 3,8% | -82% | |
| Duplicação de blocos (por 1M linhas) | 40,3 | 73,0 | +81% | |
| Chamadas cross-file (por 1K linhas) | 343 | 223 | -35% | |
| Manutenção de legado | 1,7% | 0,46% | -74% | |
| Copy/paste no mesmo commit | baseline | +41% | +41% | |
| Construções error-masking | baseline | +47% | +47% |
A tabela não mente. Estamos trocando qualidade por quantidade numa proporção grotesca.
A Armadilha da Decoerência
A engenheira Kristen Maevyn cunhou um termo que captura exatamente o que está acontecendo: a Armadilha da Decoerência (Decoherence Trap).
A definição: “o acúmulo de modelos localmente válidos porém mutuamente incompatíveis ou redundantes dentro de um sistema, de tal forma que o custo de qualquer mudança é dominado pela necessidade de traduzir entre esses modelos e prevenir efeitos colaterais não intencionais.”
Em português de dev: cada pedaço do código funciona sozinho, mas o sistema como um todo não faz sentido. Cada agente de IA, cada Copilot, cada prompt gera uma solução que resolve o problema imediato. Só que nenhum deles tem visão do todo. E quando você junta 500 soluções “localmente corretas”, o resultado é um Frankenstein arquitetural.
Maevyn argumenta que, de todas as formas de débito técnico, a decoerência é a pior. Ela cresce exponencialmente com a taxa de mudança do sistema. E a IA está produzindo mudanças numa taxa sem precedentes.
Pense assim: antes, um dev escrevia 50 linhas por dia e tinha tempo de pensar em como elas se encaixavam no todo. Hoje, uma ferramenta de IA cospe 500 linhas em 5 minutos, cada uma “correta” isoladamente, e ninguém tem bandwidth cognitivo para verificar se o conjunto é coerente.
O caso Microsoft: quando a pressa cobra a conta
Breck McKye cita o caso da Microsoft como exemplo emblemático. Um ex-engenheiro da empresa, Axel Rischin, declarou publicamente que “a Microsoft lançou o Azure às pressas sob intensa pressão competitiva. Atalhos foram tomados.”
O resultado? Em 2026, uma falha de configuração de rede causou um colapso em cascata dos serviços. Não foi um bug obscuro. Foi consequência direta de complexidade acumulada em infraestrutura que ninguém entende completamente.
E esse é o ponto que McKye martela: não estamos lidando com incidentes isolados. Estamos lidando com perda de cognição organizacional. As empresas estão perdendo a capacidade de entender seus próprios sistemas.
Quando o Shai Hulud atacou o ecossistema JavaScript em maio de 2026, explorando pipelines CI/CD mal configurados e vulnerabilidades na cadeia de dependências, a reação da comunidade foi um misto de pânico e “eu avisei”. Porque todo mundo sabia que a base era frágil. Ninguém tinha incentivo para consertar.
E a PHP2Shell? Uma vulnerabilidade de memória que existia há mais de dez anos no PHP (que roda 70% dos sites do planeta) foi explorada usando ferramentas de IA para encontrar padrões de vulnerabilidade complexos que humanos levavam meses para identificar. A IA não apenas gera código vulnerável mais rápido. Ela também encontra vulnerabilidades no código existente mais rápido. A corrida armamentista já começou e a defesa está perdendo.
O padrão se repete em todo lugar: certificados SSL da eMudhra comprometidos por chaves privadas fracas. Bancos americanos caindo ao mesmo tempo em novembro de 2026. Cada incidente parece isolado. Juntos, formam um retrato de infraestrutura digital que opera no limite.
A cadeia de dependências: o castelo de cartas que ninguém audita
Lembra do left-pad? Em 2016, um desenvolvedor removeu um pacote de 11 linhas do NPM e meio ecossistema JavaScript caiu. Todo mundo riu e disse que nunca mais ia acontecer.
Aconteceu de novo. E de novo. E de novo.
O ecossistema open source que sustenta toda a indústria de software é mantido, em grande parte, por desenvolvedores não remunerados. McKye aponta que o modelo cloud + open source (que se consolidou entre 2014 e 2016) criou uma dependência estrutural em código que ninguém audita e ninguém paga para manter.
Adicione IA nessa equação e o problema explode. Quando uma ferramenta de IA gera código que usa 15 dependências externas, ela não verifica se essas dependências estão bem mantidas, se têm CVEs pendentes ou se o mantenedor abandonou o projeto há dois anos. Ela só sabe que a API existe e funciona no momento da geração.
O resultado é uma cadeia de suprimentos de software cada vez mais profunda e cada vez menos visível. Cada camada adicionada pela IA é mais uma camada que ninguém auditou. Cada dependência transitiva é mais um ponto de falha potencial que ninguém sabe que existe até que exploda em produção.
O dev que não consegue debugar sem IA
Talvez o dado mais preocupante não seja sobre código. É sobre pessoas.
McKye descreve um fenômeno que ele chama de desmoralização técnica: engenheiros que, progressivamente, perdem a capacidade de resolver problemas sem assistência de IA. Não porque são incompetentes, fique claro. Mas porque a complexidade do código ao redor (boa parte gerado por IA) ultrapassa a capacidade de qualquer humano de rastrear mentalmente.
É um ciclo vicioso perfeito:
- IA gera código complexo rapidamente
- Dev não consegue acompanhar a complexidade
- Dev depende mais de IA para entender o código
- IA gera mais código complexo
- Volta ao passo 2
O paper da ArXiv sobre “Dívida Epistemológica” formaliza isso: estamos acumulando uma dívida de conhecimento onde os engenheiros entendem cada vez menos o que estão construindo. A “atrofia cognitiva” não é metáfora. É um fenômeno mensurável.
Quando 84% dos devs usam IA mas só 33% confiam nela, o que temos é um exército de profissionais operando com ferramentas que eles mesmos consideram não confiáveis. Imagina um piloto que não confia no piloto automático mas não sabe mais voar manual. É exatamente aí que estamos.
5x mais copy/paste do que refactoring
Eu quero voltar nesse número porque ele merece um parágrafo só pra ele.
Em 2022, devs tinham 2x mais propensão a refatorar do que copiar/colar. Em 2026, a proporção inverteu: 5x mais copy/paste do que refactoring.
Isso explica tudo. Se você entende uma base de código, você refatora. Extrai funções, generaliza padrões, limpa interfaces. Se você não entende (ou se o código foi gerado por uma máquina e você tem medo de mexer), você copia o bloco, cola em outro lugar e reza.
A IA não está apenas gerando código ruim. Ela está criando uma cultura onde ninguém mais mexe no que já existe. O código vira um museu: só adiciona, nunca reorganiza.
E cada camada nova de código copiado é mais uma camada de decoerência. Mais um modelo “localmente válido” que pode entrar em conflito com outro em produção. Mais um deploy que talvez quebre. Mais um incidente às 3 da manhã.
O que a indústria pode fazer (se quiser)
Não vou fingir que tenho a solução mágica. Se tivesse, estaria vendendo consultoria, não escrevendo artigo. Mas os dados apontam caminhos claros:
Medir qualidade, não só velocidade. O Cortex report mostra que times obcecados com PRs por semana estão cegos para o change failure rate. Meça os dois. Se seu time está mergando 50 PRs por semana mas 30% causam rollback, você não está sendo produtivo. Está gerando retrabalho.
Forçar refactoring como métrica. Se a GitClear mostra que refactoring caiu para 3,8%, a resposta não é proibir IA. É tornar refatoração parte do processo. Sprints de cleanup. Code review focado em duplicação. Alertas automáticos quando duplicação de blocos ultrapassa um threshold.
Tratar a decoerência como bug. Quando duas partes do sistema implementam a mesma lógica de formas diferentes, isso não é “estilos diferentes de código”. É um bug de arquitetura. Detecte e corrija.
Investir em legibilidade. O artigo de McKye bate nessa tecla: software moderno perdeu legibilidade. Ninguém entende o sistema completo. Documentação arquitetural, diagramas de dependência, sessões de knowledge-sharing entre times. Nada disso é sexy. Tudo isso é necessário.
Não confiar cegamente no output de IA. Parece óbvio, mas os dados mostram que não é. Se 84% dos devs usam e só 33% confiam, existe um gap enorme entre comportamento e julgamento. Code review de código gerado por IA precisa ser mais rigoroso, não menos.
O problema não é a ferramenta
Eu não sou contra IA no desenvolvimento. Uso todos os dias. A ferramenta é absurdamente poderosa para prototipagem, para gerar boilerplate, para explorar soluções rápidas.
O problema é que tratamos IA como substituto de engenharia quando ela é, no máximo, um acelerador. Engenharia de software não é sobre escrever código. É sobre entender sistemas, manter coerência, gerenciar complexidade. A IA é excelente na primeira parte e péssima nas outras duas.
E a indústria sabe disso. O próprio Gergely Orosz, do Pragmatic Engineer, levantou a questão: “quando a IA escreve quase todo o código, o que acontece com a engenharia de software?” A resposta, pelos dados de 2026, é: ela atrofia. A skill mais importante do engenheiro (entender o sistema como um todo) é justamente a que a IA não substitui e que está se degradando mais rápido.
O relatório da GitClear projeta que 2026 vai marcar um gap de qualidade de 40%: o volume de código entrando no pipeline vai exceder a capacidade de verificação das equipes de review. Não é mais questão de “precisamos de processos melhores”. É uma questão matemática. Produzimos mais do que conseguimos revisar.
623 milhões de commits não mentem. Refactoring em extinção, duplicação recorde, failure rate subindo, confiança despencando. O software que roda o mundo está ficando mais frágil a cada sprint, e a velocidade com que produzimos código só mascara o problema.
McKye encerra seu artigo com uma frase que ficou na minha cabeça: “O software moderno não tem legibilidade suficiente para suportar a responsabilidade que a sociedade deposita nele.”
Ele está certo. E enquanto celebramos quantos PRs por semana nosso time abre, a fundação racha em silêncio.













