O debate sobre inteligência artificial substituindo programadores esquentou nos últimos anos. Enquanto muitos temem perder seus empregos para os assistentes de código, poucos param para analisar os dados reais. E a verdade pode surpreender: tanto humanos quanto IAs criam bugs, mas de formas muito diferentes.
Eu já trabalhei com mais de 300 software houses e vi de perto o impacto do débito técnico acumulado por décadas de código humano. Bugs não são exclusividade da IA. Na verdade, o problema dos bugs é muito mais antigo e profundo do que qualquer assistente de código poderia causar.
Neste artigo, vou apresentar dados concretos de pesquisas recentes para responder uma pergunta que todo desenvolvedor está fazendo: afinal, quem cria mais bugs, a IA ou os programadores humanos?
O Custo Bilionário dos Bugs Humanos
Antes de falar sobre IA, precisamos entender a dimensão do problema que já existia. De acordo com o relatório do CISQ (Consortium for Information & Software Quality), o custo da baixa qualidade de software nos Estados Unidos atingiu US$ 2,41 trilhões em 2022. O débito técnico acumulado sozinho representa US$ 1,52 trilhão.
Para colocar em perspectiva: segundo o relatório Developer Coefficient da Stripe, 42% da semana de trabalho de um desenvolvedor é gasta lidando com débito técnico (13,5 horas) e código ruim (3,8 horas). Isso equivale a cerca de US$ 85 bilhões em custo de oportunidade perdido anualmente no mundo inteiro.
Outro dado relevante: um estudo da Microsoft concluiu que 58% do tempo de um desenvolvedor é gasto apenas tentando compreender código existente, especialmente após o software ser implantado em produção. Quando o débito técnico atinge níveis extremos, correções de bugs frequentemente introduzem novos bugs, criando um ciclo vicioso que não tem nada a ver com inteligência artificial.
O que Dizem os Estudos sobre Código Gerado por IA
Agora vamos aos dados sobre IA. O relatório “State of AI vs Human Code Generation” da CodeRabbit, publicado em dezembro de 2025, analisou 470 pull requests em projetos open source no GitHub. O resultado: código gerado por IA produz aproximadamente 1,7 vezes mais issues do que código escrito por humanos.
Os números específicos são reveladores: 1,75x mais erros de lógica e correção, 1,64x mais problemas de qualidade e manutenibilidade, 1,57x mais achados de segurança e 1,42x mais problemas de performance. Em termos de segurança, o código de IA foi 2,74x mais propenso a introduzir vulnerabilidades XSS e 1,91x mais propenso a criar referências inseguras a objetos.
Em paralelo, uma pesquisa do GitClear em 2025 identificou um crescimento de 4x no clonagem de código em projetos que utilizam assistentes de IA. Pela primeira vez na história, o volume de código “copiado e colado” ultrapassou o de código “movido”, o que sugere uma tendência preocupante na reutilização irresponsável de trechos.
O Paradoxo da Produtividade com IA
Aqui está o ponto mais fascinante de toda essa discussão. Um estudo randomizado conduzido pela METR em julho de 2025, com desenvolvedores experientes de projetos open source, revelou algo inesperado: desenvolvedores usando IA foram, em média, 19% mais lentos do que os que codificaram sem assistência.
O mais curioso é que, antes do experimento, os desenvolvedores previram que a IA os tornaria 24% mais rápidos. E mesmo após obterem resultados mais lentos, ainda acreditavam que a IA os tinha acelerado em cerca de 20%. Esse fenômeno ficou conhecido como o “paradoxo da produtividade da IA”.
Os dados do Cortex Engineering Benchmark Report de 2026 confirmam essa tendência em escala: embora o número de PRs por autor tenha aumentado 20% ano a ano, os incidentes por pull request subiram 23,5% e as taxas de falha de mudança cresceram aproximadamente 30%. Ou seja, mais código está sendo produzido, mas com mais problemas.
A pesquisa do JetBrains Developer Ecosystem Survey de 2026 complementa esse cenário: equipes usando assistentes de código com IA gastam 60% mais tempo em ciclos de code review comparado a fluxos de desenvolvimento tradicionais.
Mas a IA Também Tem Seus Méritos
Seria injusto ignorar os avanços. A própria pesquisa do GitHub mostrou melhorias mensuráveis quando o Copilot é usado corretamente: legibilidade melhorou 3,62%, confiabilidade 2,94%, manutenibilidade 2,47% e concisão 4,16%. Desenvolvedores com acesso ao Copilot tiveram 53,2% mais chance de passar em todos os 10 testes unitários do estudo.
Equipes com uso extensivo de IA completaram 21% mais tarefas e criaram 98% mais pull requests por desenvolvedor. Isso mostra que, quando bem orientada e com processos de revisão adequados, a IA pode sim ser uma ferramenta poderosa de produtividade.
O ponto fundamental é que a IA funciona melhor como copiloto, não como piloto automático. Desenvolvedores que tratam sugestões de IA como rascunhos a serem revisados, e não como código final, tendem a obter os melhores resultados.
Linguagens Tipadas: Onde a IA Brilha
Um aspecto pouco discutido é o impacto do tipo de linguagem de programação na qualidade do código gerado por IA. Em linguagens fortemente tipadas como TypeScript, Rust, Go e Java, a IA tende a produzir código significativamente mais confiável. O sistema de tipos funciona como uma rede de segurança que captura erros antes mesmo de chegarem à revisão humana.
Em projetos grandes e complexos, onde humanos frequentemente introduzem bugs por não compreenderem completamente todas as dependências e efeitos colaterais, uma IA bem treinada pode ter vantagem. Ela consegue analisar um volume muito maior de contexto e manter consistência que seria difícil para um humano depois de horas de trabalho.
Por outro lado, em linguagens dinamicamente tipadas como Python e JavaScript, os riscos aumentam. A pesquisa da ACM mostrou que 29,1% do código Python e 24,2% do código JavaScript gerado pelo Copilot continham fraquezas de segurança, abrangendo 43 categorias CWE diferentes.
O Verdadeiro Problema: Processos, Não Ferramentas
Depois de analisar todos esses dados, minha conclusão é clara: o problema nunca foi e nunca será apenas sobre quem escreve o código. O problema real está nos processos.
Considere que, em média, 25% do esforço de desenvolvimento é desperdiçado em problemas causados por débito técnico. Entre 40% e 50% do tempo de desenvolvimento vai para trabalho não planejado. Esses números existiam muito antes da IA entrar em cena.
Commits assistidos por IA são mergados em produção 4x mais rápido que commits regulares, o que significa que código inseguro pode passar pelos ciclos normais de revisão. Projetos usando assistentes mostraram um aumento de 40% na exposição de segredos (como chaves de API e senhas). Esses são problemas de processo, não de tecnologia.
A solução não é rejeitar a IA, e sim adaptar nossos processos. Code reviews mais rigorosos, testes automatizados robustos, análise estática de segurança e uma cultura de qualidade são essenciais, independentemente de quem (ou o quê) escreveu o código.
Conclusão: O Futuro é Colaborativo
Os dados mostram que tanto humanos quanto IAs criam bugs, cada um com seus padrões característicos. Humanos acumulam débito técnico massivo ao longo de décadas, gerando um custo trilionário para a indústria. A IA, por sua vez, pode introduzir mais issues por linha de código, especialmente em áreas de segurança.
Mas a narrativa de “IA vs programadores” é uma falsa dicotomia. O futuro do desenvolvimento de software não é sobre substituição, é sobre colaboração inteligente. As equipes que vão prosperar são aquelas que souberem usar a IA como uma ferramenta complementar, com processos sólidos de revisão e qualidade.
Se você quer se preparar para esse futuro, invista menos tempo debatendo se a IA vai roubar seu emprego e mais tempo aprendendo a trabalhar com ela de forma eficaz. Os números não mentem: com os processos certos, a combinação humano + IA pode ser mais poderosa do que qualquer um dos dois sozinhos.
Este artigo foi baseado no vídeo “IA vs Programadores: Quem Cria Mais Bugs? A Verdade Revelada!” do canal de Thulio Bittencourt no YouTube.
Foto de capa: Daniil Komov no Pexels.
