Open Source sob pressão: a explosão de PRs gerados por IA e seus impactos na segurança

O Open Source é uma das bases do software moderno

Grande parte dos softwares comerciais utilizados atualmente depende de componentes Open Source.

Seja uma startup, um e-commerce, um banco ou uma grande empresa de tecnologia, é comum que uma única aplicação utilize dezenas ou até centenas de bibliotecas de terceiros.

Frameworks, bibliotecas de autenticação, clientes HTTP, ORMs, ferramentas de observabilidade, componentes de interface e sistemas de mensageria são apenas alguns exemplos de dependências amplamente utilizadas.

Em muitos projetos, essas dependências são atualizadas automaticamente por ferramentas como Dependabot, Renovate e pipelines de CI/CD. Isso significa que uma alteração aprovada em um projeto Open Source pode, direta ou indiretamente, chegar a milhares de sistemas em produção ao redor do mundo.

Por esse motivo, a saúde e a segurança do ecossistema Open Source não são apenas um problema dos mantenedores. Elas impactam toda a indústria de software.

---

A explosão de Pull Requests impulsionada pela IA

Ferramentas como GitHub Copilot, Claude Code, Codex, Cursor e outras reduziram drasticamente o custo de produzir código.

Hoje é possível gerar uma correção, uma refatoração ou até uma funcionalidade inteira em poucos minutos.

O resultado é previsível:

• Mais Pull Requests.
• Mais Issues.
• Mais propostas de melhorias.
• Mais relatórios automatizados.
• Mais comentários gerados por IA.

O problema é que o custo de gerar código caiu drasticamente, enquanto o custo de revisar código continua sendo essencialmente humano.

O gargalo mudou de lugar.

Antes o desafio era escrever software.

Agora o desafio é validar se o software gerado merece confiança.

---

O problema das contribuições sem contexto

Uma característica observada por diversos mantenedores é o aumento de contribuições que parecem corretas à primeira vista, mas não demonstram compreensão real do projeto.

Frequentemente esses Pull Requests:

• Resolvem sintomas e não causas.
• Ignoram decisões arquiteturais existentes.
• Não seguem padrões internos.
• Não consideram compatibilidade retroativa.
• Não entendem regras de negócio.
• Não possuem testes adequados.

O código compila.

Os testes passam.

Mas isso não significa que a alteração seja correta.

---

O aumento de solicitações duplicadas

Outro efeito colateral é a duplicação de trabalho.

Quando um problema é identificado, diversos desenvolvedores podem utilizar IA para gerar soluções semelhantes e enviar múltiplos Pull Requests para a mesma questão.

Isso gera:

• PRs praticamente idênticos.
• Correções repetidas.
• Refatorações equivalentes.
• Discussões duplicadas.

O resultado é que os mantenedores passam mais tempo triando contribuições do que efetivamente evoluindo o projeto.

---

O impacto nos mantenedores

Existe uma percepção equivocada de que projetos Open Source amplamente utilizados possuem grandes equipes dedicadas.

Na prática, muitos deles dependem de:

• Pequenos grupos de desenvolvedores.
• Trabalho voluntário.
• Horários fora do expediente.
• Financiamento limitado.

Enquanto o número de contribuições cresce, a quantidade de revisores especializados permanece praticamente a mesma.

Esse desequilíbrio gera um problema conhecido por qualquer equipe de engenharia:

fadiga de revisão.

Quanto maior o volume de mudanças, mais difícil se torna analisar cada contribuição com o nível de profundidade necessário.

---

Quando produtividade se transforma em risco de segurança

A segurança de software depende fortemente da qualidade das revisões.

Uma equipe sobrecarregada tende a:

• Revisar mais rapidamente.
• Confiar excessivamente em testes automatizados.
• Analisar menos detalhes.
• Priorizar quantidade em vez de profundidade.

É justamente nesse cenário que vulnerabilidades podem passar despercebidas.

Alguns exemplos incluem:

• Falhas de autenticação.
• Falhas de autorização.
• SQL Injection.
• Cross-Site Scripting (XSS).
• Vazamento de informações sensíveis.
• Dependências inseguras.
• Introdução de comportamentos inesperados.

O problema não é necessariamente a IA gerar código inseguro.

O problema é a combinação de:

Mais código sendo produzido + mesma capacidade humana de revisão.

---

Um pequeno projeto pode impactar milhares de empresas

A cadeia de dependências moderna é extremamente conectada. Uma única biblioteca pode ser utilizada por:

• Frameworks.
• Plataformas SaaS.
• Aplicações corporativas.
• Aplicativos móveis.
• Sistemas financeiros.
• Infraestruturas críticas.

Quando uma vulnerabilidade é introduzida em uma dependência amplamente utilizada, o impacto pode se espalhar rapidamente por toda a cadeia de software.

É justamente por isso que ataques à cadeia de suprimentos (Supply Chain Attacks) se tornaram uma das maiores preocupações da indústria nos últimos anos.

---

O futuro da segurança de software

A tendência é que a geração de código fique cada vez mais barata. Ao mesmo tempo, a validação continuará exigindo conhecimento humano especializado.

Por isso, nos próximos anos, a indústria provavelmente precisará investir mais em:

• Revisão de código especializada.
• Auditorias de segurança.
• Ferramentas de análise estática.
• Testes automatizados mais robustos.
• Verificação de dependências.
• Políticas específicas para contribuições assistidas por IA.

A produtividade proporcionada pela IA é real. Mas confiança não pode ser gerada automaticamente.