Lol, I could kind of understand (not really support) his use of AI. While I doubt it’s something you can do for long without starting to make compromises, people who were a really good programmers before will probably use it responsibly for a while, until their skills inevitably erode and (more importantly) their willpower slowly runs out.
But this argument made me loose all my respect for him. It’s so utterly stupid. I hate it when i have to check my assembly code line by line, because it’s not guaranteed that the compiler will compile the same code I’ve written deterministically, and basically just randomizes what it outputs. Or when my editor does not save what I typed, and instead decides based on a random language statistics what to actually save, so I have to double-check my text word-by-word every time.
Oh, wait. No, because the tools are deterministic, and that doesn’t happen. But of course, adding randomness into your workflow, where you have to focus and review everything line-by-line, is the same as using deterministic tools, lol.
His point is that an LLM is just another tool for increasing productivity, the same as a compiler or IDE. The quality of the code is the only metric that should be judged.
And the person you replied to is saying it is not just another tool because tools are deterministic.
Except they’re not? Very few tools are deterministic. Only Mathematics is, and that’s only a small subset of tools.
You’re free to argue that non-deterministic tools lack value, but that’s clearly false: OCR only exists because of lossy training machine learning algorithms. Or, going even more basic, Monte Carlo simulations are by far the most efficient method of testing entire categories of problems that are intractable deterministically.
LLMs can be shitty, as a business practice, due to their unpredictability, but (hopefully obviously) that depends on how it’s used.
I’d argue that Monte Carlo is a bad example here, and is an example of a deterministic tool.
You use a tool to create an outcome, you’re looking for an answer or a solution that you can trust.
If you want to examine behavior of a system that has input variables across some known range, you could brute force it, try every single possible combination and wait a millennia. Or you use a monte carlo strategy, let randomness enter the simulation to build out a basic characterization. You want more detail? More confidence? Increase the number of runs. I can trust that if I increase the number of runs I gain higher fidelity, if the tool/strategy was non deterministic I couldn’t do that
The point is a tool is something you wield. Your skill is needed for and improved by the use of a tool. An LLM is an automation. You don’t wield it, you give directives. Your skill is unnecessary for its use and is left untrained. The worst part is that, unlike a good, deterministic automation (like cruise control), where you understand the limitations and can take over to avoid them, you can’t do that with LLMs. The best you can do is carefully review the slop output.
tell us of a software tool that isn’t deterministic.
“Deterministic” compilers and reproducible builds are actually fairly difficult problems. (Yes I know technically the compiler is deterministic, but AI is also technically deterministic since you can set the seed).
It’s not just about being deterministic. A compiler crucially follows clearly defined formal rules on what is a correct output given some input, which the programmer can fully rely on.
You can add deterministic testing to AI output though?
Indeed, my code has never been more rich in unit tests now that coding assistants make them so easy to add. If the coding assistant subsequently does something weird that changes program behaviour it knows immediately.
where you have to focus and review everything line-by-line
Do you not think all code deserves this level of focus?
Not parent commenter, but no, not to the same degree.
The level of trust I have in a source greatly changes how I review it. If I know that I’m reviewing code from a competent developer, I’m going to see a for loop and look for why is this here, how does it play into the larger objective and if I’m happy with it, I move on. But if I don’t trust the developer as much, I’m looking at far more like what data type is being used in the indexing, what’s the break condition, can go off the rails into random memory.
Competent developers make mistakes too. I think it’s worth at least skimming every line in a PR. Things like indexing out of bounds should probably be handled by testing or using a memory safe language.
I don’t think code review is the place where you should be trying to catch bugs in the minutia of the code. You should be assessing readability/maintainability, architectural decisions, risk, and testing strategy. That does involve reading all of the code, even if only by skimming.
I guess I don’t really count skimming as reading haha
When looking for readability, maintainability, etc what I mainly look for are design patterns. If you’re using the same boilerplate and layout I’m going to start skipping over sections
I also mainly work on high performance embedded systems that are difficult/nearly impossible to unit test and I dont always have line coverage metrics. A lot more verification by inspection in my corner of the world
high performance embedded systems that are difficult/nearly impossible to unit test
Sort of a change in topic, but I’m curious why that would be so difficult to test.
There’s a couple big reasons, sometimes you only have to deal with one or two, other times you’re hit with all of them.
The data source for the algorithms often comes from arbitrary memory addresses that live outside the context of the C, C++, or Rust runtime. If I want to read CPU core temp I send magic numbers to one address to configure ADC channel conversion, another magic number somewhere else to do the conversion, wait a few dozen microseconds, then read a third new address that I squint one eye, spin around 10 times, and do a handstand and I’ll get a number that looks like temperature.
If I’m running on the microcontroller, I’m essentially in production environment and I can’t control what the data is. If I recompile for a different system (say x86 Linux) then I’m almost certainly going to segfault. I could abstract out the reading of the data, but then on my tiny 8MHz microcontroller that has to run it’s main loop at 1000Hz, I only have a few thousand clock cycles to get everything done, calling functions, pushing/popping the stack takes a lot of time.
Adding to the pile-on most microcontrollers have <1MB of RAM, many in the tens of kilobytes range so I don’t have much of a stack to work with and I need to keep even the number of instructions down.
Even if you do all the abstractions, you then have extra logic you have to write to simulate what is happening and subtle behaviors that are timing dependant. It frequently is extremely difficult to do that as the documentation rarely fully describes everything, so you can lull yourself into a false sense of security that you’ve tested the code and it’s correct, but then you get stuck on a register value that never changes and a watchdog timer comes along and resets the hardware on you.
And that’s not the getting into the runtime or build environments, flashing procedures, limited flash cycles, and a million other business constraints that technically you can do it, but at that point your dev team has all taken the month off to go play Half Life 3
That definitely increases the challenge of writing tests or trusting that they are faithfully representing your production environment.
I could abstract out the reading of the data
I was going to suggest this, and it sounds like that ends up being expensive. It seems like you need some kind of test harness that’s able to emulate your specific hardware while still allowing for testing hooks that don’t impede the tight clock scheduling.
You do that inherently when you are writing the code. Every line you write has already had that focus, because you had to come up with it.
That you should also not trust every line of the compiled assembly after you wrote the code, and check it lime by line, is an extremely stupid argument.
Of course, you should get someone else, with a fresh/unbiased opinion to review your code too, but just the act of figuring out every line you write is in some sense a rewiev, that there is at least a plan or reason why it was written.
AI just randomly generates code without thought or reason, and you have to check everything. Unlike assembly generated from code.
That you should also not trust every line of the compiled assembly after you wrote the code, and check it lime by line, is an extremely stupid argument.
I guess it’s good that no one is making that argument then.
that is the argument linus is making… he is comparing a deterministic tool (a compiler that outputs the same assembly every time) to a non-deterministic tool and saying that they are the same type of tool. that require the same level of review, when they do not.
he is comparing a deterministic tool with a non-deterministic tool
Yes, but that’s not the argument Mikina was stating. Linus was never advocating for reading assembly line by line. Linus was using that as a satirical example, not suggesting anyone should actually do that.
Why does everyone who starts using AI always devolve into posting like this?
Maybe because when they actually try them out they’re discovering that AI coding agents are pretty good?
They don’t even need to be pretty good. They just need to be better than the parade of absolute morons who couldn’t engineer their way out of a paper bag but think they are a Senior Developer because they managed to bluff their way through 3 years in an outspurcing company by cutting and pasting from Stack Overflow. They make up 90% of the software development workforce, and they are the ones that have been burning out the real Software Engineers since the day the first Bangalore development centre opened.
Thankfully, that bar has been crossed; AI is already at the level where you don’t have to explain to it what a semaphore is using stick figures and crayon - this is an absolute golden fucking era for senior engineers and architects.
Probably because they get pissed off by the illogical anti-AI crazies.
This is a seriously weak and narrow argument. First off, the parallel drawn with existing tools is shallow. When was the last time an editor or a compiler promised to replace employees? Which of those notably accelerates climate catastrophe? Which one of those is the biggest theft of labor in the history of humanity? Everything is political. Externalizing the social and environmental cost of the major LLMs is taking a clear stance in favour of the late stage capitalistic tech empires currently taking shape.
deleted by creator
I thought it was devastating to lose Steve Yegge to AI psychosis. But damn. This is… unspeakably bad. Like if the guy in charge of the CDC decided Tylenol caused autism or like if the guy who controls the U.S. military decided it was a good idea to bomb Iran.
Linus says he only cares about quality and refuses to make a hardline rule explicitly banning LLMs in all contexts
This is… unspeakably bad
Man, genuinely… how do people not understand why nobody takes the Anti movement seriously?
They were already irrelevant in real life years ago. You only see these loser holdouts on places like lemmy.
If everyone you thought was smart are disagreeing with you, perhaps take another look at your position on the matter? Might be a reason beyond spontaneous mass “psychosis.”
If everyone you thought was smart are disagreeing with you…
Plenty of people I thought were smart before the AI bubble started think of AI as I do today.
This might get me banned here but I mostly agree with him
AI is a tool and the problem world wide is that nearly everyone is using the tool wrong
But used right, it can be a huge benefit. We know how deeply checked and tested all code is (who doesn’t remember the continuous Linus rants?) so why does it matter if submitted code covers a bug that was discovered through AI, or even written by AI? As long as the code checkers know and understand what happens, I dont see the problem with the code having been written by a tool
Obligatory AI doesn’t exist, its LLM’s, and LLM’s are tools, and tools are fine as long as you use them well.
If companies suddenly started making two meter long chainsaws and people started running around with these chainsaws cutting little girls in half, then yeah, people would rightly question if we shouldn’t ban those tools too.
Force AI companies to be responsible for how their products are used and wait to see how fast things would get better.
And for developers: as long as every commit is reviewed and checked by humans, to me its just another tool being used to make Linux better
For those arguing the water of energy and the theft of intellectual property, it’s the same point: governments need to put rules in place to control the stupid growth of data centers, AI companies must be held yo account for the data they’ve stolen, absolutely. However, that doesn’t mean that LLM’s are tools without any use
He’s right about the tool aspect of it, but, and I cannot emphasise this enough, it is not just a tool. Though we all bow (or salivate) before our fake materialist gods, and cast aside the beauty and relationships in the world, things are more than just their function.
It’s so funny when they try to argue that the conditions around it are somehow different and make it unethical. Like yeah, I’m against fascism and climate change, but all our previous tooling was also built on unethical grounds, this isn’t any different. You like trains? The railroads were built by slave labor, extracting the fuel displaces indigenous people and hurts the environment, and folks like Carnegie used their train-powered wealth for their own personal benefit to the detriment of the public. Does that mean taking a train is unethical?
deleted by creator
He’s drunk the AI Kool-Aid.
Won’t anyone think of the environment or small communities? AI is a nice-to-have, not an essential. We need to stop developing technology without thinking long term about the world we live in. We can’t use the “oh we didn’t know” excuse anymore.
Software Developers need to learn that there is a world outside of their projects. I do not care if it makes your life easier, this technology is having worldwide impacts we are not prepared for. It’s leaf blower mentality. They don’t care that the neighborhood stinks like 2 stroke exhaust, they don’t care that it’s loud as hell, they don’t care where the leaves go, their yard is clean and that’s all that matters.
Comparing AI to traditional tools is a bad faith argument and it’s a bummer to see Linus fall for it.
Well, it was nice while it lasted.
*slaps an orange flag over the tux sticker on my laptop*
2027 will be the year of the NetBSD desktop, guys!
He’s been like this for a while now (at least a few months), I admit it affected my choice of OS for a new machine.
I use FreeBSD btw.
I love how people with a fraction of his development experience are shitting on him now because his opinion on an aspect of development doesn’t align with theirs.
It’s because he’s making a poor argument, as explained better by others throughout this thread.
Don’t compilers have some guarantee of behaviours? I.e even if you don’t know exactly what instructions and order the compiler generates there is a guarantee that it is computationally/mathematically equivalent to the statements you wrote. Otherwise it would be a pretty terrible compiler. That’s a pretty big jump to writing instructions you don’t understand, since LLMs can’t make the same guarantees about a prompt/request.
Tell me you weren’t around for the early days of compiler development without telling me you weren’t around for the early days of compiler development…
(Actually, for niche architectures LLVM is also pretty bug-riddled. Maybe with AI we can finally fix some of that.)
What was the non-determinism in compilers? Honest question. Like, where does it comes from?
If you had a bug in a compiler, and a code that caused it, would it, for the same input and architecture only show some of the time? Does it included randomness in how it handles output?
Being bug-ridden is not the same as non-determinstic, if you can reproduce the bug everywhere and thus fix it, so I’m honestly curious where would the non-determinism of compilers come from.
Firstly, non-determinism isn’t nearly the gotcha you think it is - it’s trivial to make an LLM deterministic by just passing one parameter to the inference engine.
Secondly, nothing is non-deterministic in a strict sense on any traditional computer architecture (including the ones LLMs run on). Given all the inputs, and all the algorithms I can recreate the output; what makes the output ‘non deterministic’ is the complexity of the input and the feasibility of doing that. Frankly, compilers come pretty close to reaching the necessary complexity to be practically non-deterministic; anyone who had never spent days banging their head against code that works perfectly with debug enabled but fails utterly when compiled with release optimisations, but only when two logically entirely unrelated pieces of code happen to be written in a particular order, and then only if interrupts are enabled on the target… Well, anyone who hasn’t been through that has no business calling themselves a software engineer - and certainly no business telling other software engineers what tools they are allowed to use.
Honestly, a bunch of wets brought up on PHP and Javascript and managed runtimes now thinking they’re qualified to dictate what Real Programming entails is just laughable.
Frankly, compilers come pretty close to reaching the necessary complexity to be practically non-deterministic; anyone who had never spent days banging their head against code that works perfectly with debug enabled but fails utterly when compiled with release optimisations, but only when two logically entirely unrelated pieces of code happen to be written in a particular order, and then only if interrupts are enabled on the target… Well, anyone who hasn’t been through that has no business calling themselves a software engineer - and certainly no business telling other software engineers what tools they are allowed to use.
that is still deterministic… you don’t understand what deterministic means.
go ahead and show us an llm that is deterministic with a parameter passed to the inference engine. I’ll wait.
Reading comprehension not your strong point, huh?
Tell me, is it PHP or Javascript you’re l33t in? Actually, don’t bother… plonk.
Anyone claiming to do “real programming” shouldn’t be listened to. It’s incredibly clear you don’t know what deterministic means.
I know it’s early, but so far y’all just throwin’ rocks. No intelligent criticism whatsoever of the content you just read (you did read it, right?) - nothing but low-effort jeers. Linus is saying he expects high quality work and doesn’t accept a shotgun zero-tolerance mindset against how it’s produced. What, in concrete terms, is actually wrong with that?
Exactly, the only thing that matters is results.
The only intelligent people that I trust are those that use drugs and drink until they drop!
If you deny to consume those things than you ate dumb!
What? It’s obvious that it can lead you to a downwards spiral, into alcoholism, a life of mental problems and struggles? Create a toxic environment around you, make your family worry and suffer because of those actions? Makes the world a even worse place? Oh well that’s on you being weak, you should’ve been smart and know how to use the things well.
It’s weird that you only trust people who take drugs to exess and harm.
I too only trust people who take drugs, but not those who harm themselves and those around them with excess. Caffeine, prescription drugs, recreational drugs too if they don’t do as you suggest, those are fine.
I don’t really trust anyone who would turn down a vaccine or antibiotic. Those people are even worse than the heavy drug users. They take neurotic beliefs to the point of harm even worse than the “destroy the family with drug use” people.
I agree, tbh. If your submissions are bad, they’re bad. If your submissions are good, they’re good.
This is exactly right and I love Linus so much for cutting through the emotion every time. All he cares about every single time is if the commit is good or bad. Thats how it should be.
'all he should care about is that we increased profits, the effect on everything external has no bearing on my decisions"
the earth hates people like you.
You put a made-up quote in my mouth and then got angry at it. I said commits should be judged on their merits. I said nothing about profits or ignoring harm.
They are equivalent. Your quote:
This is exactly right and I love Linus so much for cutting through the emotion every time. All he cares about every single time is if the commit is good or bad. Thats how it should be.
So the only thing that matters is that the commit is good. Not whether the commit turns on DRM for every Linux machine on the planet, not if the commit starts requiring age verification for every user, not if the commit fucking bombs every city on earth.
Your reasoning is literally ignoring harm.
I said nothing about profits or ignoring harm.
No, you implied it with a dog whistle. And now you’re pretending like you didn’t.
Linus being Linus :)














