Category: Linux · Open Source · AI
Level: Foundational
In 2024, the Linux kernel's private security list received two or three bug reports a week. By March 2026, according to Willy Tarreau, the pace was already between five and ten a day. The interesting part is not the volume itself, it is the hit rate: most of those reports are valid. And that is exactly where the problem lies.
AI tools have collapsed the cost of finding a bug. The cost of fixing it, testing it, reviewing it and taking responsibility for the fix has not changed, and it falls on a small group of maintainers who look after the software behind most of the internet's servers, Android and nearly every supercomputer. That mismatch is what this post is about.
Until recently, an AI-generated report meant AI slop: convincing text about bugs that did not exist, which did not survive the first test. Easy to spot and even easier to discard.
According to the maintainers themselves, that changed abruptly early this year, over a span of weeks, with no clear cause. The models got better and AI-assisted reports started pointing at real problems.
Greg Kroah-Hartman gave a concrete example: a simple request to one of these tools returned 60 issues, each with a proposed fix. Roughly a third were wrong. The other two thirds held up, even if they needed human adjustment. That is a meaningful error rate (the best models still fail somewhere between 25% and 33% of the time, without showing any doubt), but for people who have always done this work by hand, the gain in scale is enormous.
Daniel Stenberg, maintainer of curl, describes the same transition: the useless reports have practically disappeared, replaced by something harder to manage, high volume with high quality. In other words, the difficulty was never AI being wrong. It started when AI began to be right.
The intuitive conclusion would be: more bugs found, more secure kernel. In practice, what reaches the list is repetition. The same defect in the networking subsystem shows up three, four times, described in different words, because several people ran similar tools (often the same one) against the same code.
Willy Tarreau, who helps triage the list, described exactly that scenario: something new every day and a growing volume of duplicates. In May, Linus Torvalds used a release-candidate announcement to note that the security list had become practically unmanageable, flooded with repeated reports sharing the same root cause.
The CVE count reflects it. Linux 7.0 went past 1,000 CVEs, 7.2 past 1,500, and the per-release count is now approaching 2,000, and automated AI-driven bug hunting is cited as one of the factors.
There is also an imbalance of incentives. Finding vulnerabilities became a showcase: AI companies promote scanners that sweep open source projects, and every finding becomes marketing material. The fix, on the other hand, is a cost, and the one who bears it is not who found the bug but who has to validate, fix and maintain it.
A rejection from the project would have been the natural reaction. That is not what happened.
About two months after that complaint, the community split over an automated patch review bot. Some developers wanted the right to refuse machine reviews. One went as far as arguing that there is no ethical justification for using generative AI in free software.
Torvalds' answer was categorical. As top-level maintainer, he made it clear that Linux is not an anti-AI project, and that anyone who disagrees has the exit open source itself provides: fork it or leave. He acknowledged AI can be a painful tool for maintainers, partly because it keeps finding embarrassing bugs, but noted nobody is required to use it. And he added, in a line that got a lot of attention, that AI has flaws, but natural intelligence is not always all that great either.
There is no contradiction with the May complaint. The criticism was never about the tool, it was about how it was being used. In that same message he asked anyone who wanted to contribute to read the documentation, send the fix along with the report and add real value on top of what the AI produced. The friction is short-term. In the long run, a bug found and fixed is a gain.
Torvalds uses these tools himself. Weeks later, while debugging an Intel Xe GPU driver problem (24 debug patches and 18 boots later, the fix was turning a round_up() into a round_down()), he reported that AI did a good part of the heavy lifting, despite claiming more than once that the problem was impossible.
The friction, then, is not in the technology. It is in the bottlenecks and the human strain that such an effective tool creates.
Responsible disclosure has always followed a familiar script: whoever finds a serious flaw tells the owner privately, waits for the fix and only then makes it public. The kernel's private list exists because of that model.
The model rests on one premise, that the flaw is known to few. With AI, that premise does not hold: if one person found the bug with a tool, it is reasonable to assume dozens of others found the same one.
The kernel made it official. The documentation now says that bugs found with the help of AI should be treated as public, with one important caveat: exploitation details must not be disclosed. The report states that the problem exists and the maintainer asks for more information privately if needed. Since more than 90% of what arrives is not critical, low and medium severity issues are now fixed directly in Git, without highlighting the security angle.
It is a big cultural shift. The secrecy that organized vulnerability disclosure for decades is being abandoned, not by choice, but because it stopped being possible.
With more reports than review capacity, the kernel networking team chose to shrink the surface. The tree includes drivers for 1990s network cards, amateur radio, ATM and ISDN support: technologies with very few users, but which AI tools analyze as rigorously as the rest of the code, finding bugs all the same.
Jakub Kicinski, one of the networking maintainers, was straightforward: there is no capacity to review every AI-generated fix, and ignoring security fixes is not an alternative. The proposal was to remove the code: a pull request dropping old drivers and entire subsystems such as ISDN, AX.25 (amateur radio), CAIF and ATM, about 138,000 lines in total. The rationale for dropping amateur radio support explicitly mentioned the lack of volunteers to handle the volume of AI-generated reports.
Months later, while assembling the networking changes for Linux 7.3, Kicinski estimated that between a third and half of what landed in net-next was AI-driven. In the stats for the previous cycle he had already noted that maintainers were spending around half their time trying to disprove AI reviews.
The outcome is counterintuitive: a technology that should make the kernel more secure is leading to parts of it being removed. The old code worked and bothered nobody. It became a problem once it started being analyzed relentlessly.
Some projects tried the ban route. QEMU, widely used for virtualization, prohibited AI-assisted contributions. A year later, one of its main developers suggested relaxing the rule, arguing that as the tools evolved, a total ban had become hard to defend. The proposal is still under discussion and the ban remains in force.
Torvalds explicitly rejects that approach. He said he will very loudly ignore people who try to stop others from using these tools, and that the answer to AI's downsides is not to bury your head in the sand and sing "la la la, I can't hear you".
There is also a telling counterpoint: the networking team itself, the most affected by the volume, already runs AI review bots on every posted patch and, according to the 7.3 networking pull request, has access to several frontier models, credited to Meta. The same technology that creates the overload helps absorb it. Torvalds' position sums it up well: the goal is for these tools to work for maintainers, not only against them.
One question remains: if AI finds bugs and writes fixes, could it maintain the kernel on its own?
The BPF maintainers, responsible for one of the kernel's most sensitive subsystems, posted a notice titled "summer vacation": several of them would be away at the same time, and more bugs would be marked as won't fix. Alexei Starovoitov criticized patches where someone just forwards an AI-found bug and an AI-written fix with little checking. AI is already good at finding problems, but not yet reliable at fixing them unsupervised. In his assessment, applying a hundred fixes for a hundred bugs that would never happen in production is no reason to celebrate.
On the security list, Tarreau described something similar: at the current volume, the work is limited to triage, separating what is urgent from what can wait.
This is where the real limit shows up. Every change accepted into the kernel carries a Signed-off-by line identifying who answers for it, and the project's documentation is explicit: an AI agent cannot sign. Only a person can attest, legally included, to where the code came from.
That means however many fixes the tools produce, each one depends on someone who reads it, understands it and accepts responsibility for it. And that group does not grow at the same pace. Companies hire kernel developers to build features, rarely for maintenance, which ends up happening largely in people's free time. It is a barely sustainable model, and it does not attract new maintainers. People take vacations, burn out and remove old code to keep up with the rest.
AI is not breaking Linux. It is making it obvious that a central piece of the internet's infrastructure depends on the time and attention of a group of people too small for the responsibility it carries. The scarce resource in the kernel today is not code. It is human attention.
Related: Tom's Hardware: Torvalds says AI bug reports made the security list almost entirely unmanageable · The Register: Linux kernel czar says AI bug reports aren't slop anymore · The Register: AI slop got better, so now maintainers have more work · Tom's Hardware: Linux kernel nears 2,000 CVEs per release · The Register: Linus Torvalds tells AI haters to fork off · ADTmag: Torvalds tells kernel critics AI isn't going anywhere · PC Gamer: Torvalds' debug session from hell · kernel.org: Reporting security bugs · kernel.org: AI Coding Assistants · Phoronix: Pull request to remove old network drivers and ISDN due to AI/LLM noise · LWN: Kernel code removals driven by LLM-created security reports · LWN: netdev development stats for 7.1 · BPF list: Summer vacations and "Won't Fix" bugs · The Register: QEMU mulls relaxing AI contribution ban
Categoria: Linux · Open Source · IA
Nível: Fundamental
Em 2024, a lista privada de segurança do kernel Linux recebia dois ou três relatos de falha por semana. Em março de 2026, segundo o Willy Tarreau, o ritmo já estava entre cinco e dez por dia. O dado curioso não é o volume em si, é a taxa de acerto: a maioria desses relatos é válida. E é justamente aí que mora o problema.
Ferramentas de IA derrubaram o custo de encontrar um bug. O custo de corrigir, testar, revisar e assumir a responsabilidade pela correção continua o mesmo, e recai sobre um grupo pequeno de mantenedores que cuida do software por trás da maior parte dos servidores da internet, do Android e de quase todos os supercomputadores. Esse descompasso é o assunto deste texto.
Até pouco tempo atrás, relato gerado por IA era sinônimo de AI slop: texto convincente sobre falhas inexistentes, que não sobrevivia ao primeiro teste. Era fácil de identificar e mais fácil ainda de descartar.
Segundo os próprios mantenedores, isso mudou de forma abrupta no início deste ano, num intervalo de semanas, sem uma causa clara. Os modelos melhoraram e os relatos assistidos por IA começaram a apontar problemas reais.
Greg Kroah-Hartman deu um exemplo concreto: um pedido simples a uma dessas ferramentas devolveu 60 problemas, todos com proposta de correção. Aproximadamente um terço estava errado. Os outros dois terços procediam, ainda que precisassem de ajuste humano. É um índice de erro relevante (os melhores modelos ainda falham em algo entre 25% e 33% dos casos, e sem demonstrar dúvida), mas para quem sempre fez esse trabalho manualmente, o ganho de escala é enorme.
Daniel Stenberg, mantenedor do curl, descreve a mesma transição: os relatos inúteis praticamente desapareceram e deram lugar a algo mais difícil de administrar, volume alto com qualidade alta. Ou seja, a dificuldade nunca foi a IA errar. Começou quando ela passou a acertar.
A conclusão intuitiva seria: mais falhas encontradas, kernel mais seguro. Na prática, o que chega à lista é repetição. O mesmo defeito no subsistema de rede aparece três, quatro vezes, descrito com palavras diferentes, porque várias pessoas rodaram ferramentas parecidas (muitas vezes a mesma) contra o mesmo código.
Willy Tarreau, que participa da triagem da lista, relatou exatamente esse cenário: situações inéditas todos os dias e um volume crescente de duplicatas. Em maio, Linus Torvalds aproveitou o anúncio de uma versão de testes pra registrar que a lista de segurança tinha se tornado praticamente ingerenciável, tomada por relatos repetidos com a mesma causa raiz.
O reflexo aparece nos CVEs. O Linux 7.0 passou de 1.000, o 7.2 passou de 1.500, e a contagem por versão já se aproxima de 2.000, e a busca automatizada de falhas com IA é apontada como um dos fatores.
Existe também um desequilíbrio de incentivos. Encontrar vulnerabilidade virou vitrine: empresas de IA divulgam scanners que varrem projetos open source e cada achado vira material de marketing. A correção, por outro lado, é custo, e quem arca com ele não é quem encontrou, é quem precisa validar, corrigir e manter.
Seria natural esperar uma reação de rejeição do projeto. Não foi o que aconteceu.
Cerca de dois meses depois daquela reclamação, a comunidade se dividiu em torno de um bot de revisão automática de patches. Parte dos desenvolvedores quis o direito de recusar revisões feitas por máquina. Um deles chegou a argumentar que não há justificativa ética pra usar IA generativa em software livre.
A resposta do Torvalds foi categórica. Como mantenedor principal, ele deixou claro que o Linux não é um projeto anti-IA e que quem discordar tem a saída que o próprio open source oferece: fazer um fork ou sair. Reconheceu que a IA pode ser uma ferramenta dolorosa pros mantenedores, inclusive porque não para de achar bugs constrangedores, mas lembrou que ninguém é obrigado a usá-la. E completou, numa frase que repercutiu bastante, que a IA tem defeitos, mas a inteligência natural também nem sempre é grande coisa.
Não há contradição com o desabafo de maio. A crítica nunca foi à ferramenta, foi à forma de uso. Na mesma mensagem, ele pedia que quem quisesse contribuir lesse a documentação, enviasse a correção junto com o relato e agregasse valor real ao que a IA produziu. O incômodo é de curto prazo. No longo prazo, bug encontrado e corrigido é ganho.
O próprio Torvalds usa essas ferramentas. Semanas depois, ao depurar um problema no driver de GPU Intel Xe (24 patches de depuração e 18 boots depois, a correção era trocar um round_up() por round_down()), ele relatou que a IA fez boa parte do trabalho pesado, apesar de ter afirmado mais de uma vez que o problema era impossível.
O atrito, portanto, não está na tecnologia. Está nos gargalos e no desgaste humano que uma ferramenta tão eficiente provoca.
A divulgação responsável sempre seguiu um roteiro conhecido: quem encontra uma falha grave avisa o responsável de forma privada, aguarda a correção e só então torna o problema público. A lista privada do kernel existe por causa desse modelo.
O modelo depende de uma premissa, a de que a falha é conhecida por poucos. Com IA, essa premissa não se sustenta: se uma pessoa encontrou o bug com uma ferramenta, é razoável supor que dezenas de outras encontraram o mesmo.
O kernel formalizou isso. A documentação oficial agora orienta que falhas encontradas com auxílio de IA sejam tratadas como públicas, mantendo uma ressalva importante: detalhes de exploração não devem ser divulgados. O relato informa que o problema existe e o mantenedor solicita informações adicionais em privado, se necessário. Como mais de 90% do que chega não é crítico, falhas de severidade baixa ou média passam a ser corrigidas diretamente no Git, sem destacar o aspecto de segurança.
É uma mudança cultural grande. O sigilo que organizou a divulgação de vulnerabilidades por décadas está sendo abandonado, não por escolha, mas porque deixou de ser possível.
Com mais relatos do que capacidade de análise, a equipe de rede do kernel optou por reduzir a superfície. O código inclui drivers de placas de rede dos anos 90, suporte a radioamador, ATM e ISDN: tecnologias com pouquíssimos usuários, mas que as ferramentas de IA analisam com o mesmo rigor do resto do código, encontrando falhas do mesmo jeito.
Jakub Kicinski, um dos mantenedores de rede, foi objetivo: não existe capacidade pra revisar todas as correções geradas por IA, e ignorar correções de segurança não é uma alternativa. A proposta foi remover o código: um pull request tirando drivers antigos e subsistemas inteiros como ISDN, AX.25 (radioamador), CAIF e ATM, cerca de 138 mil linhas no total. A justificativa pra retirar o suporte a radioamador mencionava explicitamente a falta de voluntários pra lidar com o volume de relatos gerados por IA.
Meses depois, ao consolidar as mudanças de rede do Linux 7.3, Kicinski estimou que entre um terço e metade do que entrou no net-next era motivado por IA. Nas estatísticas do ciclo anterior, ele já tinha registrado que os mantenedores gastavam cerca de metade do tempo tentando refutar revisões feitas por IA.
O resultado é contraintuitivo: uma tecnologia que deveria aumentar a segurança do kernel está levando à remoção de partes dele. O código antigo funcionava e não incomodava ninguém. Virou problema quando passou a ser analisado incansavelmente.
Alguns projetos tentaram o caminho da proibição. O QEMU, amplamente usado em virtualização, vetou contribuições feitas com IA. Um ano depois, um dos principais desenvolvedores sugeriu flexibilizar a regra, argumentando que, com a evolução das ferramentas, uma proibição total ficou difícil de defender. A proposta segue em discussão e o veto continua em vigor.
O Torvalds rejeita essa abordagem de forma explícita. Ele disse que vai ignorar, em alto e bom som, quem tentar impedir os outros de usar essas ferramentas, e que a resposta aos problemas da IA não é enfiar a cabeça na areia e cantar "lá lá lá, não estou ouvindo".
Há ainda um contraponto revelador: a própria equipe de rede, a mais afetada pelo volume, já usa bots de revisão por IA em cada patch enviado e, segundo o pull request de rede do 7.3, conta com acesso a vários modelos de ponta com crédito à Meta. A mesma tecnologia que gera a sobrecarga ajuda a absorvê-la. A posição do Torvalds resume bem: o objetivo é que essas ferramentas trabalhem a favor dos mantenedores, e não apenas contra eles.
Resta a pergunta: se a IA encontra falhas e escreve correções, ela poderia manter o kernel sozinha?
Os mantenedores do BPF, um dos subsistemas mais sensíveis do kernel, publicaram um aviso intitulado "férias de verão": vários deles ficariam ausentes ao mesmo tempo, e mais bugs seriam marcados como "não será corrigido". Alexei Starovoitov criticou os patches em que alguém só repassa o bug achado pela IA e a correção escrita pela IA, sem checar quase nada. A IA já é boa em encontrar problemas, mas ainda não é confiável pra corrigi-los sem supervisão. Na avaliação dele, aplicar cem correções pra cem bugs que nunca ocorreriam em produção não é motivo de comemoração.
Na lista de segurança, Tarreau descreveu algo semelhante: no volume atual, o trabalho se limita à triagem, separando o que é urgente do que pode esperar.
É aqui que aparece o limite real. Toda alteração aceita no kernel leva uma linha Signed-off-by, que identifica quem responde por ela, e a documentação do projeto é explícita: um agente de IA não pode assinar. Só uma pessoa pode atestar, inclusive do ponto de vista legal, a origem do código.
Isso significa que, por mais correções que as ferramentas produzam, cada uma depende de alguém que a leia, entenda e aceite assumir a responsabilidade por ela. E esse grupo não cresce no mesmo ritmo. Empresas contratam desenvolvedores de kernel pra criar funcionalidades, raramente pra manutenção, que acaba acontecendo em boa parte no tempo livre das pessoas. É um modelo pouco sustentável e que não atrai novos mantenedores. As pessoas tiram férias, se esgotam e removem código antigo pra conseguir dar conta do resto.
A IA não está quebrando o Linux. Está deixando evidente que uma peça central da infraestrutura da internet depende do tempo e da atenção de um grupo de pessoas pequeno demais pra responsabilidade que carrega. O recurso escasso no kernel hoje não é código. É atenção humana.
Relacionado: Tom's Hardware: Torvalds says AI bug reports made the security list almost entirely unmanageable · The Register: Linux kernel czar says AI bug reports aren't slop anymore · The Register: AI slop got better, so now maintainers have more work · Tom's Hardware: Linux kernel nears 2,000 CVEs per release · The Register: Linus Torvalds tells AI haters to fork off · ADTmag: Torvalds tells kernel critics AI isn't going anywhere · PC Gamer: Torvalds' debug session from hell · kernel.org: Reporting security bugs · kernel.org: AI Coding Assistants · Phoronix: Pull request to remove old network drivers and ISDN due to AI/LLM noise · LWN: Kernel code removals driven by LLM-created security reports · LWN: netdev development stats for 7.1 · BPF list: Summer vacations and "Won't Fix" bugs · The Register: QEMU mulls relaxing AI contribution ban