Linux

Only if you don't care about your own cognitive decline, property theft, and climate damage

Exactly, the argument that whether the code was written entirely by hand or produced by an LLM is the wrong thing to focus on. To see why, we have to consider how software development actually works at scale.

There's a view that code written by hand has to be more intentional, almost has to be by definition since it requires the maintainer to actually put it in there themselves. That's, of course, true but once a project grows past a certain size or it has multiple maintainers, nobody really has the totality of the code in their heads. So, any new code that's added is always done with limited understanding. Code being written by hand should not be equated with it expressing the intent faithfully; if that were the case, then we'd never have software bugs. Humans make mistakes all the time as is clearly evidenced by there being no lack of buggy code predating LLM use.

I'm also not intimately familiar with most of the code in the projects I've been maintaining over the years. Any code I've written even a few months ago might as well have been written by someone else. When I need to make changes, I read through the code and figure out what it's doing, and I rely on the test harness to make sure I don't introduce regressions.

It's simply not feasible for humans to keep the entirety of large projects in their heads all at once. When you're working on a project, you're constantly forgetting and relearning code as you go. And the situation is even worse for projects where multiple people work together where nobody knows what everyone else was thinking. We look at the code and try to build up sufficient context in our heads to make the necessary changes. When we misjudge that context or misunderstand existing code, then we end up making mistakes.

The way we judge whether projects are actually solid is by the level of specification and testing they have, the experience of the developers, and amount of usage they see in the wild. All of these same tools work just as well with LLM generated code as they do with code written by hand.

Farming out design decisions to the LLM without reviewing the output or doing proper testing will almost certainly produce low quality code, but that is no different from somebody just slapping some code together to make a kludge rather than really thinking through a problem. Working with LLMs does not mean farming out your thinking to the machine. What these tools actually do is automate the mechanical aspect of producing the code. Once it is written, you can read it, understand it, and change it as you would with any other code.

I'm sure he included himself in that group

Didn’t call everyone an idiot, but he’s not wrong, humans makes mistakes all the time

In response to

I expect maintainers who want to act on sashiko reviews to triage and verify them first before bothering authors, yes.

You can run a local LLM capable of assisting in software development for less energy than running a AAA video game. I'm not denying the environmental impact of the current AI landscape, but I kind of disagree that it's intrinsic to LLMs as a whole, I think it's more a symptom of capitalism and its disregard for sustainability causing everything it touches to have a high environmental cost.

Also, nearly all modern computing has high environmental costs, certainly all cloud computing. I think instead of focusing on AI only, it would be more helpful to engage in a broader discussion on how computing can be made more energy efficient as a whole, and do proper cost benefit analysis of all things we use computers for, including but not limited to LLMs. We may well still conclude from that process that we need to stop using LLMs, in which case we should.

If you're against LLM use on environmental grounds (which I'm not disagreeing with), I submit to you that we should take the idea even further and things like gaming, video streaming, high frequency trading, social media, and any other nonessential computing should be on the same chopping block for the same reason. Applications of computing that we also use at scale with high environmental impacts, but that have been normalised and practically seen as a right by many of the same people against any amount of AI use (not saying that's you, speaking generally). Why should AI be the only thing we raise concerns about if we're to raise concerns? Doing environmental protection piecemeal by independently targeting single things and not the entire system has been shown time and time again to not work at best and make it worse at worst.

That's well outside the scope of the Linux kernel policies.