On the road to fully automated luxury gay space communism.
Spreading Linux propaganda since 2020
Rules:
We are in the beginning of a huge dark age for software development.
With stackoverflow and forums dead, a whole generation untrained, LLM-companies about to crash in the coming years, local models self-poisoning and going out of date. Deslopping all the garbage that is currently getting piled onto the entire infrastructure is going to be a slow thankless and almost entirely self-imposed waste of time.
In high profile projects like the Linux kernel, probably yeah but I think people are vastly overstating the quality of the code the average developer writes and also their overall knowledge and skill level, I've seen some shit early in my career where looking back on it now I wish I was reading AI slop, and this was software that earned millions a year.
Fact is a lot of important code that a lot of people depended on has always been kinda shit and yet it worked because there was enough manpower to keep it clanking on.
Youre right about quality but the problem isn't just code quality, its also the sheer volume of code and its unmaintainability. Quality has always been pretty low in commercial software, but there were practical limits to how much of it could be created, and with enough labor thrown at testing and maintenance, as you say it clanked on.
When it's easier to just generate a whole new page in the UI than fix bugs or make usability improvements though, when it's easier to generate a whole new separate app than to introduce a new feature into the existing one, and when completely nontechnical people are running around doing this stuff without understanding the consequences, risks, etc. I think its very fair to describe it as a dark age. Large parts of the industry and the world are already there in the thick of it, and it is bad.
Social structures will adapt but that won't bring back the old way of doing things or reduce reliance on AI, if anything it will entrench it further, until/unless costs become prohibitive
When it's easier to just generate a whole new page in the UI than fix bugs or make usability improvements though, when it's easier to generate a whole new separate app than to introduce a new feature into the existing one
That's a good point actually, before software became stable and usable only after patching it up after it collided with the real world and real users. If you're constantly rewriting shit you're constantly going to go one step forward two steps back.
I don't know how things in the industry are now, but back in my day you didn't deploy a Microsoft product until the second service pack had been released. Trusting software to be reliable and secure was always a no no.
Yeah, computer tech used to be real dogshit back in the day. Everyone waxes poetic about Windows Xp but if we’re actually being honest, Windows 11 blows it out of the water
I'd say it's still pretty shitty, you just might not be in the user base being affected. Automatic updates are probably insulating most folks from how bad things are.
This notion of “quality of output” misses something important though, which I think our economic system predisposes us to ignore.
I think most of us have this concept that the function signature of “working on code” is something like:
implement(spec): CodeChanges;
But I think this hides some stateful side-effects. There’s a monadic thing going on here, and I think it’s really more like:
implement(knowledge, spec): [CodeChanges, KnowledgeBundle];
…where KnowledgeBundle is a whole bunch of things: latent info about how things currently work, obviously, but also the yet-unnamed missing abstractions you noticed, the existing named abstractions that are starting to strain — basically the sense of the trajectory of the codebase.
Even really shitty programmers get some sense of the trajectory of the codebase, but this is something that even the best frontier models fail at.
Tangent:
I saw a pretty cool visualization of Kalman filters the other day (substantially AI-generated, coincidentally), and I thought it matched something about this dynamic.
If you’re only concerned about the “next step”, aka “quality of output”, your error will accumulate and you’ll drift over time. You need to be able to evaluate where you are, so you can correct that error and stay on course. And to do that, you need to be present inside of the code and feel where the pain points are, or your estimation will be so far off that it’s useless.
I think our economic focus on “output” and our obliviousness to internal states (or even denial that they exist at all) is going to make it very easy to fall into the trap of taking a long series of next steps that individually look very sensible, but over time accumulate unmitigated error and drift towards disaster.
I actually think we're at the tail end of the current decade long dark age. The barrier to "can't use photoshop on linux because adobe is an asshole and also costs $200/year" could be gone next year. There is a vibe coded multi-platform rust clone that you might say is 50% done and already has optimistic reviews from real photoshop users. many walled gardens and enshitified apps are at risk now.
silicon valley style tech companies want to use LLMs to ship you walled garden ball and chain slop as fast as possible, paying as few workers as possible, to steal the highest margins from the working class as possible.
the open source community wants to use LLMs to ship the safest, most privacy respecting, and otherwise highest quality software possible.
the LLMs themselves do not force you to ship low quality code. it's your choice to engage in solid engineering principles or not.
Pareto principle gets even worse for LLM code, the Photoshop clone won't exceed Krita in quality as time goes on
Torvalds answered that the kernel project only wants serious developers. That includes having access to enough resources to function in this world.
well that's the end of open source linux
this is like that mozilla dick hammering post except it's the entire linux community acting in response to windows 11
the kernel itself is becoming vibe-coded because linus decided to become a tech bro who apparently never cared about social issues, important tools like rsync no longer work because they're also vibe-coded now, GTK4 and QML apps use more system resources than electron apps now and that's all anyone seems to want to develop with for some godforsaken reason, etc. etc. etc.
i used to actually like desktop linux but now i just use it apathetically because there aren't any viable alternatives
important tools like rsync no longer work because they're also vibe-coded now
The causal relationship between these two things are not so clear. rsync is mainly maintained by a single main volunteer and regressions in software releases are common enough that LTS and rolling release are two separate categories for a while now. I think it's more accurate to say that tools like rsync are so chronically underfunded that the gap is being filled with corporate products rather than real labor. I generally don't think that framing "AI" as harmful by appealing to a sense of software quality is often not the real issue and gets debate-bro'd to hell and back by boosters anyway.
GTK4 and QML apps use more system resources than electron apps
In my anecdotal experience this isn't true at all, every electron app regularly pages more than a gigabyte of memory on startup and I've never experienced this with with GNOME or KDE applications. This is genuinely the first time I'm hearing about this.
that's all anyone seems to want to develop with for some godforsaken reason, etc. etc. etc
Theyre the big names, integrate into an ecosystem, and most of all, writing raw x11 code (or raw Wayland protocols? I'm not sure how things work over there, I'm still in X land, running motif-ass lookin software, and loving it) is a gigantic horrifying minefield of footguns.
The frameworks are fairly frustrating, but tbh I understand not wanting to write raw x11 very very well.
Truly the 2020s is the lost decade of technology. Absolutely nothing got better.
I think this article is quite a bit ungenerous of what Torvalds actually said. The only gross part here is him taking money from Meta but that's probably not the first time he accepted big corpo money, his actual stance is IMO more reasonable than what this article portrays it to be, basically he said trusted maintainers should deprioritize new contributors that are likely to be LLM slop.
That said he really should be even more conservative in his approach here, even the current amount of LLM patches to the kernel are sketchy enough, he should consider at least a temporary moratorium on LLM patches. The kernel is not some random ass app where it doesn't matter if it gets broken for a while due to LLM usage.
Are you saying the article author is just being ungenerous,or misquoting him entirely? Because it seems from the quotes presented like he did not say that new contributors are likely to be LLM slop, just that if their contributions are of "low quality" (subjectively) they should receive low priority. Amid the mountains of AI slop this means humans attempting to learn will likely be ignored and receive no (human) review. For the Linux kernel on its vaunted high horse, that may be acceptable or even desirable, but for open source in general it's not, and for open source projects trying to be free of corporate capture, a more pro-social approach is needed.
I feel like you've either misread Linus' orientation towards LLMs or the author's usage of the word slop if you think there's any chance of a moratorium on LLM patches at this stage, when they are not only already happening en masse, but removing the requirement that they even be disclosed.
The author is certainly not looking favorably on Linus' statements, and they say a few things which give me pause about their accuracy and knowledge level, but overall I find myself agreeing
I found this bit interesting:
Torvalds added that he does not want to scare off people who want to write code; his message is that you have to either put in the effort to learn, or put a lot of money into an LLM to participate.
… Torvalds and others repeatedly said low-quality contributions from new developers should receive low priority, and that the community should stop trying to make contribution easy.
All the corporate contributors are the primary ones coming in with a wave of LLM slop code, breaking the social structures that made the patch review process function, not just the random people from the internet who are more easily ignored. Ive seen it in reality, the author is correct at least about the breakdown of processes precipitated by slop just leading to more LLM usage. No human has an inherent desire to write thoughtful or helpful reviews for and teach a machine that cannot learn and does not think. Interacting with such is a very degrading experience, IMO.
Turning away randos coming in with poorly written patches was always part of the gig, but the influx of those was also a lot lower when it was just humans submitting them.
Sounds like the right policy for after the bubble pops, not before.
So uhhh, 2027 is the year of TempleOS on the desktop, right? 
In twenty seven, What once was old is now new, And the people cry
Or idk maybe haiku is also sloppified. *BSDs are cool. I used to drive OpenBSD, maybe I'll try netbsd like is mentioned.
Or...
HexbearOS when?
It's the year of the NetBSD desktop!
Tower of Slop
~~Tower of Babel~~
So the slop-gates were open. What sort of technical excellence did the antisocial warriors contribute? There’s this one from five days after Torvalds’ announcement. The message laments that the networking maintainers are drowning in slop — so they fixed this with more slop:
I don't think Linus "Linux" Torvalds is the best representative of "vibecoding" as a millionaire who has been consistently employed in his own project he created out of school.
The idea that you either need to be an expert or "spend enough money on a chatbot" is upsetting to read. Never change classism and racism in computer science. 
god damn it
genuine question from me, the uninformed: If a change or commit is being presented as code a person authored (or without indicating one way or another) how can someone tell it is LLM slop vs code a person wrote?
Like, with writing, there are sort of semi-intangible patterns that make me recognize AI slop, but even then I don’t know for sure- its mostly based on suspicion that comes from reading AI slop in the first place. Like one example I can think of is the “Not X, but Y” summarization at the end of nearly any essay or brief explanation of something. Its always meant to be poetic or impactful and it might have been a genuine style at one point -I think it was common in advertisements maybe?- but now it makes me think, “huh, this is probably slop”
So for code, is there some BS that they are always doing that feels inhuman or wrong? Do they make the same errors or add unnecessary shit that makes people roll their eyes? Or is it just a high volume of work with only a short turnover? If someone asked an LLM to write a fix to a bug they encountered, and then submitted it as their own fix, how does one know it is slop?
The Linux kernel gets a ton of PRs constantly. My big issue with LLM code is that it is really good at appearing to be thought out, but actually reverse engineering it can reveal major mistakes.
A good reviewer should still catch them, but it takes longer since the "code smell" is different. Humans will usually make consistent simple mistakes while LLMs will sometimes use advanced patterns to make the same mistake.
The fact that these take longer to review, are usually much longer in general, and are appearing at an incredible pace (1hr to generate, 1 day to review) creates a backlog that becomes unbearable to review.
A lot of open source projects have banned them for this reason, but the ones that do allow them tend to use LLM reviewers to help clear the backlog which is a whole different ouroboros of an issue.
What I hate about the review vs generation disparity is that there's suddenly pressure on the reviewer (the one gatekeeping poor quality work) to work faster under a greater workload.
If I don't review it quickly, someone who doesnt give a shit will, and they'll hit approve on slop and get a gold star for doing it fast. If you make a comment, the contributor suddenly spams 5 commits with loads of changes which need reviewing - all while that same contributor gets to work on (ruin) other shit while you're stuck with their mess.
In my last job, I could work through a problem with someone to get a good submission, with compromise of course. Since then, I work with someone who swears by AI depsite barely having a grasp of programming and I straight up want to reject half of his PRs. But can I? No, because I'm at the same level as him and get given less respect by management because I'm not churning out slop so I can be free to get invites to other meetings for technical commentary. It's a pisstake.
It occurs eventually once the slop enjoying programmer is de-skilled where they only glance at AI output and start losing track of the bigger picture.
The most obvious one for code is the "comment above a line of code that describes exactly what the code does"
# This does A with B as an input
DoA(B)
afaik LLM code is usually unnecessarily verbose and tries to include libraries that typically wouldn’t be necessary.
But also it seems that after writing work emails, writing code seems to be the thing LLMs do best.
Yes, there is a flavor to LLM code. Generally there is poor structure and comprehensibility, the more code slides right off your brain when you read it despite there being lots of comments the more likely it is to be slop. On the other hand, bad human written code tends to have a feeling of impenetrability that's often accompanied by a lack of comments.
genuinely: how bad can it be if there's human oversight. AI is like a drug, if you taste it once you're hooked especially when trying to finish projects...
All its going to do is burn out the maintainers and theyre gonna quit. Same as is happening in any corporate job where knowledgeable seniors are being pushes out by naive juniors and all ai code is implicitly trusted. All work is produced by prompt monkeys who pray it doesnt break and like all programming decisions the consequences won’t be seen until a few years down the line
realistically, what is to be done? i can't stand the idea the communities should roll over and die
It's really frustrating that anything hand made you put out is just fresh training data for these assholes.
I don't think there's a lot that can be done other than holding to our principals and hoping that the AI bubble crash eliminates all of this by causing the technology to become too prohibitively expensive to use.
Both Chinese and American vendors have brought down the costs of running models by so much. I really don't think hoping for this to pass is a viable strategy.
There's also just hiring people to do maintainership work on the same salaries (or even greater salaries) than the average software engineering position. Most of the time the excuse is "I don't have the money, training or team large enough to continue maintainership and so I used AI products."
The XZ incident happened precisely because the entire computer science field is held up by "one dude in Nebraska (TM)" while the rest create psychological torture devices to extract profit (yes Windows 11 should be classified as a torture device). Capitalists also benefit from AI being held as the scapegoat for all these issues rather than the structural faults that were built up over decades of disinvestment.
He’s also rewriting history. Linux launched and attracted its initial developers as a social movement. People worked hard to get a system with actual principles that wasn’t about screwing its users over. There were movies about this! Torvalds spoke in them! Claiming Linux was always pure technology with no social element is simply false.
No, open source has always been the capital compatible version of libre software. The main reason why Linux has gained so much market share in recent years is because of em-dollar sign fucking up with Windoze 11 and corpos like Valve investing their resources into the development of Linux.
Linus was always a techbro who "only cares about the technical aspects of open source software." This whole thing is just the chickens coming home to roost.
There was a social movement aspect to Linux in its earliest days, as in, the days before kernel 1.0. Hell, before he got the big bux to finally unshackle himself from Finland (and his communist father) to heartland of fascism, paedophilia, and capital itself.
Linux is still tiny versus Windows on desktop. Steam still shows it around 3% - a big improvement, but even Firefox is more popular. Perhaps that will change more as governments seek to leave Windows following the shitshows of migrating from XP, 7, and 10, but right now the market is undoutably locked down by Windows.
No doubt steam isn't the best metric but it's not likely to be far off that number. The kernel is only dominant due to servers (license free and its early adopters being UNIX sysadmins) and embedded/mobile (configurability letting it run on anything capable of conducting electricity) - the rest have never been central to Linux's success, nor the reason why massive datacenter stakeholders pay inordinate sums of money to the Linux foundation.
debating between a new amish cutoff of 2019 to miss ai shit or an earlier one to miss algorithmic social media
Linuslop Rustokenvalds
Oh my christ this is even worse than year or two ago, when he lamented the lack of new talent and burnout of full time maintainers. He's finally grown out of neoliberal pseudo-socialism inherited from his father and embraced the paedo-affiliates of meta and sex tourist industry plants of linus tech shits. He has gone total reactionary on anyone calling out how unsustainable this project is becoming.
Linux will outlive this husk of a developer.
uhoh
What's the actual probability that the linux kernel ever gets forked? Would it be possible to see a UZDoom type situation?
Or do I actually need to install OpenBSD 
ⓘ Remember to enable JPEG-XL support in your browser, even on your phone!
The capital is behind Linux, and as long as it fills their use cases theyll keep putting their engineers on it no matter the slop. Though the same was once said of Unix and Windows, and one day Linux plopped up and got big because it solved the problems that they couldn't.
It could end up being BSD, or some ABI-compatible kernel like Asternias. My money is on something that lets users and devs run their software and drivers without complex setup - like what WINE & Proton did for Linux desktop, but even more impactful because the server software that runs the backbone of the internet is where the money is.