Linus Torvalds used AI to fix a Linux bug, and now LLM critics on Linux face an uncomfortable choice

The open-source community is undergoing a huge shift right now. AI coding and bug-fixing have gotten to the point where people maintaining software have to draw a line in the sand: are LLM contributions allowed? And if so, how much is too much?

We're seeing that very debate being held among Linux distros. We've only just heard that Debian has given AI code the green light ; meanwhile, the Fedora community has been largely unreceptive of the idea . But one thing has held: the creator of the Linux kernel, Linus Torvalds, has allowed people to submit AI-generated code. And recently, he even used AI to fix a Linux bug . And while that holds, people who dislike AI code will likely need to find a compromise if they want to continue using Linux distros.

The world of Linux is mostly adopting AI in some way or form

People who don't want it are getting shoved out

People have all kinds of reasons why they don't want to develop using AI tools, or use products that utilize it. For some, it's an ethics problem; they see LLMs as plagiarists that steal code from other sources and regurgitate it in projects. For others, it's about the environment, with data centers driving demand for electricity and water while causing noise pollution. And others still are concerned about the legality of using AI-generated code.

However, it seems that the big names in open-source software are adopting AI in some way. Yes, if a project is built and maintained by a small team or individual, it's a lot easier to ban LLM coding; however, as soon as you go big (like with a Linux distro), you'll see much more openness for it.

We've seen the Linux kernel make room for AI code , and several large distros have allowed it. Some have been more lenient than others; for instance, while AI-written code is allowed on Fedora, developers have to declare it in their submissions. Usually, AI-accepting distros allow AI code without declaration as long as the submitter takes all responsibility for it, and from what I've seen, that's the most agreeable stance for people who don't dislike AI code at its core.

Some OSes drew a hard line, though. Gentoo has strictly forbidden AI code, and while it's not a Linux distro, NetBSD banned it to the point where it specifically labels LLM outputs as "tainted." But it seems the general shift among distros is moving toward accepting AI code.

The recent vote to decide if LLM code has a place in Debian showed that banning it was one of the least popular options, to the point where both "Ban LLM contributions from Debian via Social Contract" and "Reject LLMs as far as practical, update Code of Conduct" proposals were dropped before the votes were even tallied. A Debian developer quit after seeing the results.

Open-source software is becoming a weird hybrid of AI and human code

It's hard to separate the two now

So, the solution seems obvious. If you want to use a distro that doesn't use AI code, just...don't use a distro that allows AI code. And sure, as I mentioned before, when you use small-scale software made by a close team, that's very easy to do and enforce.

But when open-source software comes with moving parts from lots of different developers, it can be really hard to find an app that really, truly doesn't use AI code. Take the Linux kernel, for instance; you could find a distro that doesn't use AI code, and you can take solace knowing that the people managing Linux's compiler have banned LLM code . However, given how the Linux kernel itself accepts AI code (some of which was Torvalds' own generations), you're now using an OS that, at some stage, had an LLM make code for it.

AI code bans may be impossible to enforce in the first place

Bans may only be as good as the paper they're written on

So let's say we do a blanket ban on all submitted code to the Linux kernel and for all distros. Now we have another problem: how do you enforce that?

When detecting if an AI wrote an English passage, it has some telltale signs. It likes to use the em-dash, and there are specific cadences that 'sound' like an LLM wrote them. And while AI-written code may also have some tells, it's a lot harder to identify it than with writing. As such, even with an LLM ban, there's still a chance that someone, at some point, used LLM code in the project.

It may partially be why some codebases are accepting of AI code; given how it's so difficult to detect, trying to enforce a ban may mean that some human-made code is flagged as AI-written while LLM-generated code gets through without a hitch.

AI opponents on Linux may need to define a set amount of 'acceptable LLM code'

If it can even be done

So if you're someone who opposes using AI code in your distro, and you want to keep using Linux, what do you do? It seems that no matter what large-scale OS you use, there has likely been AI-generated code at some stage of its development. This then begs the question: if you're forced to accept that the OS you're using has AI code in it somewhere, then what's the upper limit until it's too much? If you accept AI code at the kernel level, are you fine with it on the distro level too? Or would you prefer to use a distro that didn't use it?

There's also the element of using an AI for non-code purposes. Take, for instance, the people who use AI agents to scan through the code and report bugs. In my earlier example with Torvalds, he also used LLM code to fix a bug, but you don't need to use AI to fix the bugs it finds. You can have the AI find a bug, write a report, and have a human fix it instead. That'll likely be far more acceptable for someone concerned about the legal issues or ethics of AI code, but there's still the environmental factor to consider.

The truth is, I don't really think there is a way to 100% guarantee that the code you're using is free of AI code when the development team gets into double digits. People may need to focus less on using 'AI-free' software and more on aligning with people who aim to minimize exposure to AI, such as Gentoo. Sure, the Linux kernel may have AI code in it, but if at least your distro rejects it, and it has a strong anti-AI stance that will attract developers who also avoid using LLMs, it's probably the best you can do.

Going 'AI-free' these days is surprisingly difficult

While people once fled Windows to escape its AI implementations, the world of LLM coding has made its mark on Linux. Granted, Linux doesn't have nearly as intrusive AI implementations as Copilot, but for people who'd rather not use applications with AI code, finding a way to "stay clean" is getting nearly impossible.