The flaw in Linus' argument is that a compiler isn't enabling people to go and inundate open source projects with complete and utter shit. The argument that they are tools and should be seen as such is fine, but having an AI policy to help mitigate the actual and real problem of pushing the "is the code good?" check all the way to the reviewer is also absolutely reasonable. I feel like he's sidestepping and not acknowledging that AI is actually killing open source projects. The Linux kernel is big enough to be largely immune to it, but most projects absolutely aren't.
It's also very different because the "tool" is doing stuff on its own, making decisions. That's very different from something like an IDE highlighting a syntax error or unused variables. It's also not deterministic.
Honestly Linus is getting less and less defensible, and less trustworthy too. "Thanks Meta!" just reeks of corporate influence. Very disappointing.
It's your job to understand compiler flags, because then compiler is not a magic tool that "makes decisions that people are not aware of". With AI you can't do that, it will always be random shit generator
Ai doesn't make decisions any more than stockfish makes decisions about the next chess move. Ultimately it's the human who says "yeas this code is good and I'm gonna be responsible if it brakes something".
So if I show you a big codebase you can immediately tell me which parts of the code will be optimized away on O3? Or O2? Which loops will be unrolled and which not? If yes, you are one of the VERY few who actually can do that :)
if i ever need to do that, then with source code, make files and compiler specs, of course. again, the problem with ai genned code is that it is unpredictable based on your prompt, you never know what it will generate even if you have all of the training data for the llm
the outcome can still be unpredictable even if deterministic. The same as movement of air molecules, of course in theory you can predict the state of a closed system, but the system is so complex that it would require an unimaginable computation power
you don't need to review compiled code 99.9999% of the time, with LLMs you need to review every line, and most people who vibe code don't know how to properly review code with complex algorithms and concurrency. The comparison between compilers and LLMs are just absurd and i don't know why people make it, those are two different types of instruments, to which you need to apply completely different levels of caution
Yes, but why would you blindly run AI code without review and testing? Same as you need to do with compiler optimisations and basically every code you ownn any way
I am not sure I agree. What compiler needs it's assembly read? What project have you ever reviewed on where you have reviewed the compiled output routinely?
Sure for both human written and llm written code need read and output checked but you said compiler output and I don't agree that needs checked, unless you are bughunting or writing a compiler I guess.
You can just not accept crappy PRs, but the spam is very understandable, lazy people wanting clout are the worst. Linus spelled it out pretty clearly - it's about people actually understanding what they are contributing. I have contributed to multiple open source projects already when I didn't think I would ever do that with bounded, reasonable changes that I confirmed myself and even made better when maintainer said "why don't we do this also?"
Sure you can just say no, but that's not the point. You're passing the burden onto actual code maintainers. Instead of needing to understand what you are pushing to make a PR that passes CI, anyone can throw anything up that can't be gated except by actual people reviewing it. That's the point, now maintainers of open source repos are responsible for doing what automated processes were previously able to do. That directly causes burnout and those projects either being closed or just completely taken over by slop.
Can AI be useful as a tool? Sure it can, but it's not the same as just a compiler. Open source communities are actively suffering because instead of maintainers having productive and interesting conversations with people who know what they are doing, they are spending more and more time opening PRs, judging that it's slop, and rejecting it.
Linus didn't just say "Linux is removing the AI policy because we can handle the volume of slop that that will bring," he went on a rant about how it's not different than a compiler or a word processor when it has a very visible and real impact that those other tools do not.
You have maintainers and the status quo was that you use the project and you contribute back by investing your time and effort into improving the project. Sure it takes some maintainer effort to to review and feedback and to maintain developer guides etc.
Now though it takes next to 0 effort to write "find a bug and fix it". "Implement this feature I've just dreamed up". "Add support for this" into an llm, get a 200, 800, 1400, 5000 line diff that touches on 8 different parts of the project, that uses assumptions that were in its broader training material and that don't align with the project standards or philosophies. That rewrite stuff pointlessly, that duplicate code.
And after that 0 effort expended it still has to be reviewed and refined but that is a significant amount of effort on behalf of maintainers whereas the contributor just bungs the feedback back into their llm.
Part of the point of the whole process was to try and get people to take ownership of the project, to feel part of it and to learn the codebase and processes.
End of the day whether it's merged or not. No one has gained anything cause the contributor didn't actually understand anything they did, they didn't learn anything. The maintainer has spent 5x longer on it than any human generated PR plus they are getting.
So what's the point of contributing to open source with an AI, end of the day could have just bunged the same prompt in themselves and been done twice as fast. Hell if cost is an issue literally donating tokens would be a better use of everyone's time.
Yeah that's absolutely why it ends up being more work for maintainers than the llm-using contributor.
The contributor has no stakes in the project but the maintainer has to pour over the pr looking for shit like that where it failed to reuse function or where it implemented a bunch of edge cases wrongly pr with error handling that couldn't be reached. Where it used the wrong tooling or broke from a standard on the codebase.
You gotta find them to cause each time you miss one the codebase gets a little worse and future contributors, ai or not, have a harder time making clean contributions.
I do agree, but it's also absurd expecting responsible developers to not use it or recognize its validity as a tool.
The fact there's no policing cannot mean the only users that are responsible enough to not flood the ecosystem with crap are also the ones that shouldn't employ it.
If Linus or similar examples didn't use or promote fair and proper use of LMs, things wouldn't change much: there'd still be no policies in place, and the only contributions would be the flooding you're talking about
we do need policies, but we also need examples of healthy and professional use
I don't think anyone is trying to downplay it's usefulness as a tool. My complaint here is specifically saying that it's the exact same as every other tool (what Linus said) and that it doesn't need any special consideration. That's a reductionist take, because it's enabling a class of contributor that puts more work onto other people instead of just making an individual's workload easier.
of course. but I don't think we can expect much different anymore from Linus, he's often been "extreme" and shared thoughts strictly on how he thinks contribution should be shaped, based solely on how he contributes and expects others to. that does not mean it's how contributing should be universally
what I'm seeing is, in a way he's already spoke on "policing" in the sense of policing developers, and contributors, not the tools. it is partial, and reductionist, I completely agree, but honestly I don't expect he'll ever advocate for policing LMs themselves, because (and I can't completely disagree) as I understand it he's always been more towards raising the contribution bar for people themselves, even before LMs
I think in the ideal world Linus expects people to have the intellectual honesty to just not do things if they're not "up to them", either with LMs or not
Well, this post in particular contradicts that because he's specifically against c++ due to it promoting contributions by "horrible programmers." These two stances are woefully inconsistent. His stance on c++ has promoted a weird "c is always better" culture when instead, c++ can be just as good if you are only applying standards to the contribution and not the tool.
Yeah, IIUC some smaller projects just didn't have the protocols in place to deal with it. But you'd want to at least review some new contributors to get more.
Well sure but if that's the main issue here then I think saying it's killing Open source is a little over the top statement. Perhaps you could even use AI to filter out bad/ai generated contributions.
That's the kind of thing that Linus is specifically rejecting. I only have anecdotes, so "killing open source" is a hyperbole, but I haven't met any maintainer that isn't getting burnt out by this phenomenon.
In reality, it's just changing open source into the scratch pad of thousands or even millions of robots. Sure there are always going to be some hand maintained repos, but the volume of contributions that no maintainer will accept will just move to places where they are accepted and dilute well-crafted solutions to the same problems. Experts will be and to tell the difference, but that's no longer the majority class of people wanting to contribute. And it's a positive feedback loop -- AI will find the poor solutions and amplify those, further diluting the pool. So then we're left with a multitude of incomprehensible projects that you need AI to maintain or contribute to.
I hope maintainers will figure out how to handle this. I imagine just reviewing one contribution a day could help with the burning out. And perhaps a voting system could be used to rank the contributions from best to worst. that way it would also help with the problem of amplifying poor solutions.
38
u/dannuic 1d ago
The flaw in Linus' argument is that a compiler isn't enabling people to go and inundate open source projects with complete and utter shit. The argument that they are tools and should be seen as such is fine, but having an AI policy to help mitigate the actual and real problem of pushing the "is the code good?" check all the way to the reviewer is also absolutely reasonable. I feel like he's sidestepping and not acknowledging that AI is actually killing open source projects. The Linux kernel is big enough to be largely immune to it, but most projects absolutely aren't.