Linus knows this codebase better than anyone alive

Does he? Is it even possible to know the entirety of the Linux kernel within one head?

Eh I really think it does. You don’t news to load everything into context. You need to load where everything is located into context.

Have you considered that you might be an ai, yourself? I hear only AI makes these mistakes.

Wild how mad you are about this.

Only for the Visual Studio implementation. The general term is autocompletion.

Aha, gotcha--thanks!

Does one need to know the entirety in their head to know it better than anyone else? If not Linus, who?

There is no concept of a filesystem in our brains. Weird hills, and such and so forth

I'd argue the people who wrote the code for the various subsystems know more about it than the guys who "just" review and merge them.

Even good programmers are captured in poor practices due to short timelines and end up delivering shit code.

Eh it depends, you can use AI to help you fix AI slop.

A hand written project I worked on was such a mess I can't even begin to describe how badly written it was.

It was a POC writen by students that then just got launched as the actual product for millions of users.

The DB had zero foreign keys.

The thing just had to be rewritten from scratch

Only because you don't think of it as one. It's just a different medium for the storage of information.

That isn't equivalent to memories.

Verifying LLM code isn't necessarily harder than verifying a human PR. I hope that this also boosts automated test tooling so that it also gets easier to test these PRs, since the focus will shift to review rather than writing.

What makes you think he wouldn't have made the same mistake hand coding it?

If he didn't catch it on his own review the likelihood that he would've made the same mistake if he coded it himself is high.

Not really

First of all, if a human makes a mistake it's a learning opportunity. When a human misses a bug an LLM hallucinated, noone really learn from it.

I like to compare it with the xray machines at airports. Human operators stare at the screens hunting for weapons and other prohibited items and miss pretty obvious stuff because they get bored out of their minds. They actually added a mechanism to insert fake xray images of weapons ever so often to actually keep the operators interested and alert. Ain't much too different from doing code reviews being the human-in-the-loop/scapegoat.

Also, LLMs don't necessarily generate good code. They excel at generating good-looking mediocre code.

So yeah, I'm gonna go ahead and claim that Linus is more likely to miss a bug a LLM wrote on his behalf than one he wrote himself.

The TSA has to pretend to even keep their employees looking busy. Hilarious.

Verifying 10 pounds of incoherent architectural choices and over engineered submodules is certainly harder than reviewing tee bits of coherent human work.

reading code you didn't write is genuinely more tiring than writing it

What I keep saying. Good take except that you don't use "AI" tooling, you use copyright evasion slop tooling.

He's spiraling downward, so even if he once lnew the kernel best, I am sure he no longer does by a long shot.

Yup! I love AI for banging out object models.
I can give it a pdf listing the spec with what amounts to hundreds of member variables and getters setters. I can say “hey AI turn this into a class, use the GOF builder pattern, and boom it does it. Saves me hours of monotonous typing.

it shouldn't be that impactful negatively that AI is being used

Doesn't it invalidate the GPL? Open source licenses depend on copyright, and LLM-generated code isn't copyrightable.

(Also, it can't be proven not to contain plagiarised proprietary code, in fact it's quite likely that it does; between this, the testing / review burden, and the mental decay of developers that use LLMs instead of coding, this pretty much kills open source projects, in several different ways to make sure they stay dead...)

And verifying 10 pounds of incoherent architectural choices and over engineered submodules of human work is certainly harder than reviewing tee bits of coherent agent work.

You are? I can also make false dichotomy fallacies!

Every time somebody says Microsoft is now shit because of AI, I have to remind them windows has been human slop since Vista.

The difference is that AI is prone to this issue, even a single agentic process. Humans only really run into this issue with large, disorganized teams.

Humans burn out.

https://maevyn.codes/decoherence

edit: hold up. Presenting as though what I said works in reverse,

verifying 10 pounds of incoherent architectural choices and over engineered submodules of human work is certainly harder than reviewing tee bits of coherent agent work.

as though agentic and human contribution is equatable… wouldn’t that be false equivalency? Tisk tisk…

Human work is not swappable with agentic work without tradeoffs, which is kind of why I was making a point at all.

It's not that they're not copyrightable. That court case is misunderstood. The vibe coder tried to give the AI the copyright and the judge ruled that was stupid because AI can't own shit.

Also copyright doesn't mean much anymore because companies are rewriting open source software as copyrightable vibe coded bullshit the same way people are "open sourcing" Adobe using vibe coded crap.

It's garbage "progress" all the way down.

First of all, if a human makes a mistake it’s a learning opportunity. When a human misses a bug an LLM hallucinated, noone really learn from it.

Agents can "learn" from their mistakes within their harness.

You or the agent can add notes in the memory files or the repo level agents.md files, or standards and conventions files to look for those mistakes.

Most harnesses these days will spin up a new agent to do a review once the implementation is done, that agent will take memory files, agents.md files and other standards and conventions files into its context to know what to look out for so it won't make the same mistake twice

Claude code is even doing "dreaming" where it'll do a cron every night to look through all the conversations from the day for stuff it messed up on and add to its memory files to not do those same mistakes.

That's a fair point that I hadn't considered

Well no editorilorizing in that title. no sir. /s is this the change that also have produced articles that stress kinda the opposite.

[...] if a human makes a mistake it's a learning opportunity.

As per Linux kernel AI policy (and a common fucking sense), you're the one responsible for the code that is submitted from your side, regardless of the tools and pipeline you use. Now get this, when an agent makes a mistake, that you didn't notice, that's still a learning opportunity, especially when you're held accountable for the fuck up.

Also, LLMs don't necessarily generate good code. They excel at generating good-looking mediocre code.

True... When you give them a general task that involves solution of technical problems and decision making. But when it's a concrete "do the x thing over here, using this, this, and this", which is then accompanied by your manual review of the changes, they actually do fine, basically allowing you to minimize the tedium, while not robbing you of the most interesting and important parts of development.

Did Linus's pipeline look like what i described, tho, when he introduced the aforementioned bugs? Was it his technical decision that, by proxy, introduced bugs? I don't know. Regardless of the answers, he's a grown-ass man, and thus is responsible for the consequences of his decisions.

Is he more likely to introduce a bug now that he uses AI? Only time will show. I might be wrong, but i think Linus is too smart for it to be the case.

i'm too autistic to understand, whether this is a sarcasm

Ergo, you should leave as little places for AI to make mistakes, undiagnosable by static analysis tools, as possible. In other words, make all the technical and algorithmic decisions yourself.

I started using Linux about 30 years ago. I wasn't a science major, but reading about the GPL and the GNU movement, it seemed to fit really well with my values. I was willing to put up with a lot (the first distro I used didn't come with a working XFree), but it was worth it, to me. I never really sat well having Linus at the head. He just seemed like a bit of a prat most of the time, but whatever. Then I got nnoyed enough that I spent a year or two going through alternatives. I had used BeOS before I found Linux, but at the time BeOS had gone away and Haiku didn't exist. Plan9 had a lot of cool things, but wasn't a daily driver. Spent time mostly with FreeBSD, but after being a GPL fan, the BSD licensing just kind of annoyed me. Lately I've been finding myself feeling the same way I felt about the BSD world. It would be nice to get away from Linux and Linus, but at this point I'm much older, less willing to jump through hoops to get shit working. I'm hoping some kernel alternative comes along that ticks the boxes for me. Maybe Hurd will get there (ha!). I sure wish something would come along. Although, like worrying about the climate, or US politics, the momentum towards comprehensive social shittery just feel completely inevitable and I should try not to worry about it. I guess.

Pa.

Ra.

Graphs.

Does an Alzheimer's patient learn things just because they read the same note every morning explaining the reality to them?

It was a POC writen by students that then just got launched as the actual product for millions of users.

Classic. I really don't understand why anyone would do this.

This whole situation reminds me of people's distrust for Big Pharma. Forgetting the actual problem and just assuming everything it produces is evil and will kill you. The problem with big pharma isn't that modern medicine doesn't work, it's that pharmaceutical companies charge so much for it that poor people are condemned to die preventable deaths in the name of profit.

The problem with AI isn't that it can't produce good code, it's that it's capable of producing a shitload of bad code at volumes no human can possibly review. It doesn't surprise me at all that the guy who made Linux can wrangle an AI to produce exceptionally good outcomes. The problem is that there's a million Joe Normals who are gonna try to replicate it with no idea how to audit the output.

Plus all the employees who've been forced to produce and sift through that garbage code, because their bosses bought into the hype and don't see the software for what it actually is.

I thought code couldn't be copywritten? It's instructions, isn't it?

Half a century of companies suing each other over code licenses suggests otherwise

Too many people believe they are AI is capable hands.

You putting quotes around "learn" and "dream" is you admitting that they are not really doing either. LLMs don't think, learn, reason, analyse, design or anything else that require a human mind.

You making a note in agents.md did not teach the model anything, it's a halfassed attempt to compensate for the fact that LLMs are INCAPABLE of learning. You need to create a new model trained on the new data you wish to incorporate, because when that phase is over the model is locked in.

Have a look at the claude code leak and you will see how they actually prompt inject constantly to try to keep it on track and not do stupid shit. It has fucking CYBER ALZHEIMERS for gods sake.

Look at that woman at meta who told an agent to suggest which emails to archive, explicitly forbidding it from deleting anything. Guess what? That internal monologue filled up the context and that instruction fell off the back of the truck, and the clanker happily started shredding emails until they literally pulled the plug.

LLMs are somehow passing the Turing test for a subset of humans and its embarassing that the bar is apparently that low. The AI labs are doing their best to weaponize that and you fell for it.

Despite the "AI policy and common sense" saying that the contributor is responsible for understanding the code committed, Linus did clealry not treat this with the due dilligence required. He used unproven error-prone technology to emit code for a project that millions of users depend on and sent it in despite it having the race condition and the performance regression.

If Linus was as smart as you seem to believe, he should have checked that code as if it was submitted from his worst enemy, as if it was written by a smarter and malicous adversary or at least a very enthusiastic imbecile. But the LLMs are designed in a way that trick you into believing that they are smart, reasoning and capable and you drop your guard. The code looked good, he got fooled and here we are.

People are morons or just don't give a F.

Sometimes both

This is an old argument

"Skill issue" was a dumb argument for pushing against rust, and it's still a dumb one now. There are plenty of reasons not to want LLMs in the Linux kernel, no need to make Linus sound like some godlike entity who's never written buggy code before LLMs

But sometimes worth repeating.

Yet even for those Joe Normals, I kinda like the democratising effect that they're now able to produce software, or modify existing software for their own use. Just don't fool yourself into thinking it's enterprise grade. Understand your limitations. And don't spam open source projects with slop PRs because you think the AI makes you a software wizard.

Instructions can be copywritten just like recipes can.

Code is just a recipe for computer brains