AI Slop no open source: Godot e cURL reagem ao lixo gerado por IA

A inteligência artificial prometeu acelerar o desenvolvimento de software. Mas, em 2026, uma preocupação ganhou força dentro da comunidade open source: o excesso de contribuições ruins geradas por IA.

O problema ficou conhecido como AI Slop. Na prática, o termo descreve conteúdos criados por inteligência artificial que parecem úteis à primeira vista, mas carregam erros, informações inventadas, código mal revisado ou explicações sem valor técnico real.

Projetos importantes como Godot e cURL começaram a reagir a esse movimento, criando regras mais claras para lidar com código, relatórios e pull requests gerados por IA sem revisão humana adequada.

A pergunta que fica é simples: a IA está ajudando o open source ou está criando uma nova crise de qualidade?

• AI Slop é o nome dado a conteúdos gerados por IA que parecem convincentes, mas têm baixa qualidade.
• Projetos open source estão recebendo pull requests, relatórios de bugs e textos criados por IA sem validação humana.
• O Godot anunciou regras mais rígidas contra agentes autônomos, vibe coding e código substancial autorado por IA.
• O cURL encerrou seu programa de bug bounty com recompensa após queda forte na qualidade dos relatórios recebidos.
• O problema não é usar IA como ferramenta, mas enviar conteúdo que o próprio autor não entende, não testou e não consegue corrigir.

AI Slop pode ser entendido como lixo gerado por IA: conteúdo com aparência profissional, mas pouco valor real.

Pode ser um texto bonito, mas cheio de informações falsas. Pode ser uma documentação bem escrita, mas tecnicamente errada. Pode ser um código que parece correto, mas não respeita as regras do projeto. Também pode ser um relatório de vulnerabilidade que soa grave, mas descreve um problema inexistente.

No desenvolvimento de software, esse ruído aparece principalmente em pull requests, issues, documentação, relatórios de bugs e relatórios de segurança.

Um estudo publicado no arXiv em 2026 analisou discussões de desenvolvedores sobre o tema e descreveu o AI Slop como um problema que aumenta o atrito de revisão, reduz a confiança nas contribuições e transfere o custo da produtividade individual para mantenedores e revisores.

Em outras palavras: uma pessoa gera algo rápido com IA, mas outra pessoa precisa gastar tempo verificando se aquilo realmente funciona.

A maior parte dos mantenedores não está dizendo que ninguém pode usar IA. O problema é usar IA sem entender o resultado.

É pedir para uma ferramenta gerar código, copiar a resposta e enviar para um projeto real sem testar, sem revisar e sem saber explicar o que foi feito.

• Pull requests criados por IA sem testes.
• Bugs inexistentes descritos como problemas reais.
• Vulnerabilidades inventadas.
• Documentação tecnicamente errada.
• Código que até compila, mas quebra padrões internos do projeto.
• Contribuições em massa feitas apenas para ganhar reputação no GitHub.

Isso cria uma situação perigosa para projetos open source. A pessoa que envia a contribuição gasta poucos minutos, mas o mantenedor pode gastar horas tentando entender, testar, responder e fechar algo que nunca deveria ter sido enviado.

O caso que mais chamou atenção recentemente foi o do Godot, um dos motores de jogos open source mais conhecidos do mundo.

A Fundação Godot anunciou mudanças em suas políticas de contribuição para reduzir o peso sobre mantenedores e lidar com o aumento de contribuições geradas por IA.

Entre as diretrizes anunciadas, o projeto afirma que não aceitará uso de agentes autônomos de IA, não permitirá vibe coding e exigirá que código substancial seja escrito por humanos. A assistência de IA deve ficar limitada a tarefas pequenas, como autocompletar código, regex ou substituições simples.

A documentação de contribuição do Godot também reforça uma regra importante: quem usar IA precisa revisar, melhorar, testar e declarar o uso no pull request.

O ponto central é responsabilidade. Se um código quebra, alguém precisa entender o que foi feito. Se uma correção causa um bug, alguém precisa conseguir explicar. Não basta dizer que a IA gerou.

Projetos open source normalmente parecem grandes por fora, mas são mantidos por poucas pessoas por dentro. Muitas vezes, quem revisa código faz isso no tempo livre.

Quando chegam dezenas ou centenas de contribuições ruins, o trabalho do mantenedor muda. Em vez de corrigir bugs reais, melhorar desempenho ou criar novas funcionalidades, ele precisa investigar relatórios fracos, responder mensagens repetidas, fechar issues sem sentido e revisar código que não deveria ter sido enviado.

No caso do Godot, a própria fundação afirmou que a revisão de pull requests é um dos maiores gargalos do projeto e que precisa garantir que o tempo de quem revisa seja bem aproveitado.

A IA pode aumentar a quantidade de contribuições. Mas quantidade sem qualidade vira custo. E no open source, esse custo geralmente cai em cima de voluntários.

Outro caso importante envolve o cURL, ferramenta open source extremamente usada para transferência de dados e presente em muitos sistemas, aplicações e dispositivos.

Em janeiro de 2026, Daniel Stenberg, criador do cURL, anunciou o fim do programa de bug bounty com recompensa. Segundo ele, o programa deixaria de existir oficialmente em 31 de janeiro de 2026.

O motivo principal foi o aumento de relatórios ruins, muitos deles ligados ao chamado AI Slop. Stenberg explicou que, a partir de 2025, a taxa de relatórios confirmados como vulnerabilidades reais caiu para menos de 5%. Antes, o programa costumava ter uma taxa acima de 15%.

Depois, o cURL voltou a aceitar relatórios de segurança pelo HackerOne como canal oficial, mas sem programa de recompensa financeira. A segurança continua sendo tratada, mas o incentivo financeiro foi removido para reduzir submissões ruins.

Esse caso mostra um risco claro: quando fica fácil gerar relatórios de vulnerabilidade com IA, também fica fácil inundar projetos com alertas falsos. Quanto mais ruído existe, mais difícil fica encontrar o sinal verdadeiro.

A discussão sobre AI Slop no open source não tem apenas um lado. Quem critica o uso indiscriminado da IA afirma que ela está piorando a qualidade das contribuições, sobrecarregando mantenedores e incentivando pessoas a enviarem código que não entendem.

Do outro lado, há quem defenda que a IA pode ser uma ferramenta poderosa quando usada com responsabilidade. Ela pode ajudar iniciantes a entender código, acelerar tarefas repetitivas, sugerir testes, revisar trechos simples e apoiar documentação.

O problema, portanto, não está em usar IA. O problema está em tratar a IA como autora final de uma contribuição. No open source, quem envia precisa ser responsável pelo que envia.

Para desenvolvedores, a mensagem é muito clara: usar IA não é o problema. O problema é não entender o que a IA gerou.

Se você usa ChatGPT, Claude, GitHub Copilot ou qualquer outra ferramenta para programar, precisa revisar o código, testar o funcionamento e ser capaz de explicar a solução.

• Eu entendo esse código?
• Eu conseguiria corrigir se desse erro?
• Eu testei o comportamento?
• Eu li as regras de contribuição do projeto?
• Eu estou ajudando o mantenedor ou criando mais trabalho para ele?

Projetos como Godot deixam claro que contribuição não é apenas entregar código. Contribuição também envolve responsabilidade, comunicação, revisão e respeito pelo tempo da comunidade.

Na visão da Central Stack, a polêmica sobre AI Slop mostra que o mercado está entrando em uma nova fase da inteligência artificial.

A primeira fase foi o encantamento. Todo mundo queria testar IA, gerar código mais rápido e automatizar tarefas. Agora começa a segunda fase: a cobrança por qualidade.

No desenvolvimento de software, velocidade sem entendimento pode virar dívida técnica. E no open source, essa dívida muitas vezes é paga por pessoas que nem receberam nada para revisar aquele código.

Por isso, a reação de projetos como Godot e cURL não deve ser vista apenas como rejeição à IA. Ela deve ser vista como defesa da responsabilidade humana.

A IA pode ser uma ótima assistente. Mas ela não assume compromisso com manutenção, não participa da comunidade, não responde por falhas em produção e não entende todo o histórico de um projeto. Quem responde é o desenvolvedor.

A inteligência artificial aumentou a capacidade de produzir código. Mas também aumentou a quantidade de conteúdo ruim disfarçado de contribuição.

Projetos open source não precisam apenas de mais pull requests. Eles precisam de boas contribuições, feitas por pessoas que leem a documentação, entendem o problema, conversam com a comunidade e entregam algo que possa ser mantido.

A regra daqui para frente deve ser simples: use IA para acelerar, use conhecimento para validar, use testes para provar e use responsabilidade para contribuir.

No fim, o problema não é a inteligência artificial escrever código. O problema é o ser humano enviar esse código sem entender o que está fazendo.