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.
Yes, they are deterministic. LLMs are not.
I am curious about the downvotes; what I said is factual. LLMs use random numbers in deciding output, so they are not deterministic.
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.
I don’t know… tools made by companies who can’t wait to get in bed with the Pentagon to kill brown people around the world would seem to be toxic af.
If we’re playing the altruism olympics game, everyone is already throwing stones in a glass house as it is, because virtually all electronics and batteries on Earth are made from materials mined by forced/child labor.
Yes, but… here comes the next squeeze. I know that they would sell us the rope to bang them with, but god damn.
Surely the Linux kernel gets used by those same organizations too, in some way
Don’t call me Shirley, though
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.
Global solar generation has increased by 50% in the last 2 years, meanwhile a token is something like 900 times less energy consuming than it was a year ago?
Something comes first, almost free energy and deeply embedded ai usage or total environmental collapse, capitalism deems that we will find out which in due course.
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.
You can’t really control the use of tools though, that is the problem. AI detection doesn’t work and leads to a lot of false positives. The only thing you can do is check if the product is good.
AI is horrible for the world but it is impossible to ban it for coding, as you can easily submit AI generated code that looks human.
He is not comparing the effects that tools have but that you can’t control if someone uses them or not.
The only way I see for controlling the way AI is used, is if the AI companies put restrictions on it.
If you ban AI, the vibe coders will just lie about the origin of their code.
AI detection doesn’t work and leads to a lot of false positives
Anthropic have begun watermarking their outputs (which is possible thanks to EU legislation) so yes you can detect ai output.
Most ai output has been watermarked since I think 2023, Anthropic is just more open about it.
I am pretty sure this still produces too many false positives when applied to code because of the way these watermarks are implemented. I am not 100% sure on that though. It could be used on commit messages though.
You can’t really control the use of tools though
You start on a false premise. Immense swathes of the legal system are designed to control the use of tools, are they not? Legality aside, most people aren’t sociopaths, and can handle being responsible humans. You don’t even mention that, in many cases, you can just ask.
He is not comparing the effects that tools have but that you can’t control if someone uses them or not.
I don’t agree that he’s talking about verifiability or honesty.
I don’t see the argument that if some bad actors are going to lie in PRs, that we should just let the floodgates open.
You’re correct but still completely missing the point.
The only way to implement anti-LLM rules is to detect AI-assisted code. That, in and of itself, is a problem because it’s impossible to detect good code that was AI assisted. And you don’t need rules against slop because it’s bad code.
If I’m following it correctly, Linus is advocating for tightening submission requirements before it gets to human review, which directly targets the harms FOSS projects are having under the deluge of slop: it raises the bar so that the slop needs to be good enough to warrant a review, which filters out must of the noise, leaving more of the signal.
Anti-LLM policies are like having closed-book take-home exams: you’re left wildly guessing what’s cheating (or not). Instead, make the exam open book, but expect better answers.
Linus also says AI is a useful tool, and he is an expert, so we must accept that he feels that way. I don’t know if he’s commented on the environmental/social/political consequences of AI hyperscalers, but that’s a separate argument.
The tech is here. It’s impossible to detect. It’s foolish to think you can ban it’s use
And it can be run locally, so there’s no stopping it, even if there was political will to do so. (And with a reasonable economic and ecological cost, no less—ignoring IP/political consequences here, since that’s a whole other topic.)
You’re correct but still completely missing the point.
Thanks ;)
The only way to implement anti-LLM rules is to detect AI-assisted code.
From direct experience, this just isn’t true. I contribute to a small open source project, and we’re doing well enough for our purposes by simply saying “no AI”. We’re not checking, we work on good faith. That’s enough for us. We have no reason to think people are circumventing it.
I think AI needs to be regulated on a larger scale. The tools need to be restricted if you want to stop people from using them.
Putting up rules against tool use without making access to the tool more difficult are worthless.
Putting up slop PRs doesn’t have to be intentional from the authors side.
How would you check commits for AI use if it is not mentioned anywhere? How would you enforce anti-AI rules?
I contribute to a small project, where we simply ask that PRs don’t include AI, then we proceed on the basis of good faith.
On the small scale the good faith approach works. But on the scale of the linux kernel it would have minimal to no effect to ban AI contributions.
For the code quality it’s better to enforce proper reviewing and checking of the code instead of banning specific methods of producing code.
Banning AI is as enforceable as banning vscode.
I myself don’t use ai in general and I despise the attitude towards ai of some people in the community but I don’t think banning ai on this side of the problem has any effect on the code quality and the way things are contributed. I think ai needs to be regulated on a government level. Like removing datacenters or financing of ai companies, which both can also be done on a local government level.
I can well imagine things are different at that scale
The last paragraph of the screenshot is problematic regardless though.
Strongly agree with this, except for “everything is political”, which I firmly disagree with.
Linus seems to be tunnel vision in focusing on how good it is as a tool. That, relatively speaking, I couldn’t care less about. That tunnel vision, however, is existentially dangerous. He is, in some ways, acting as bad as the likes of Thiel.
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.
where you have to focus and review everything line-by-line
Do you not think all code deserves this level of focus?
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.
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.
“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.
What do the tests do?
They check to make sure that the code continues producing the expected results. For example if I had some code that added up numbers, I might have a unit test that calls that function with the parameters “2” and “2” and checks to make sure the result is “4”. If something changes that makes it start returning something else then a flag is immediately raised.
Are these tests written by AI? Have you reviewed the tests? Do they cover all code paths and all the possible inputs and outputs? Do the tests have requirements cited (traceability)?
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.
AI is a tool
If you mean “only a tool”, this is wrong. See for example https://www.youtube.com/watch?v=yZUuKzDQSsI (ignore the stupid title)
AI is a tool and the problem world wide is that nearly everyone is using the tool wrong
Maybe if the tool is so finicky that it’s practically impossible to get right, it’s a bad tool? For sure millions of programmers are just prompting it wrong… Can’t be that it’s just not as great a tool as the AI overlords claim
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
Until the code checkers resort to LLMs because the agentic coders submit so much code for review. I will just let AI run over this one time, what could go wrong? I’ll tell AI to generate test cases beforehand to make sure it gets the implementation right. Bad tests never lead to problems right?
Or maybe, just maybe people eating up a constant stream of propaganda produced by those whose whole financial future is tied to AI being the universal solution to every problem (and some they have to create in the first place) are indeed a problem.
Just because 24/7 advertising tells you to hammer in screws doesn’t mean it’s the smart thing to do. And neither does it show how useless a hammer is as a tool.
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?
Things were bad before AI, so let’s make them worse.
AI is a tool and the problem world wide is that nearly everyone is using the tool wrong
Because the public discussion devolved into some insane fight between people ideologically against any AI (funnily often the argument “it’s stealing other people’s work” is coming from people that are fundamentally against copyrights in every other case) and some not less crazy people believing that AI is their new lord and savior (and a lot of them are paid or the followers to said paid influencers you just changed one idol (tech billionaires) to another one as instructed…).
It’s basically a mud fight between those believing that hammers are inherently evil and need to be destroyed and those that think everything in this world is a nail. Nothing in-between.
I think you are critically (I’m not saying intentionally) missing the middle ground in your assessment. Large generative models are great for repetitive, homogenous tasks like surveillance, speech recognition, assembly line quality control, etc.
If I try to look at it from your point of view, regarding creative tasks like developing new software, you have one side claiming that you can make hammers out of chocolate and throw away all your proper ones, and another that’s portrayed as being unreasonable for opposing that.
I’m not missing the middle ground. I am criticising that there is no middle ground in this fake discussion manufactured to keep engagement going.
Every single time someone makes a nuanced argument that is not matching one of the two dogmatic extremes (so exactly that Linus Torvalds is doing here, just –Linus being Linus– not very diplomatically phrased) the same kind of people start screaming about the end of the world (see again: this very thread where idiots express their condolences for Linus finally going insane by not denouncing AI alongside those praising the fact that he finally has seen the light an embraces AI as our saviour).
Why does everyone who starts using AI always devolve into posting like this?
it’s crack for burnt out programmers who don’t enjoy the process of creating software anymore. You get to have results without putting in any work of your own. In corpo-world where everything is a metric, outputting massive amounts of code quickly and effortlessly is a great thing. For the others who actually enjoy making something it’s a useless tool.
I generally try to avoid using AI for my hobby projects, but I think there is still a niche for it in working out issues that take a disproportionate amount of time to track down manually relative to the scale of the fix. Things like a subtle typo somewhere or missing some hyperspecific nuance of whatever stack I’m working with. In those particular cases I would say it actually enhances my own creative ability insofar as I don’t need to spend hours of effort banging my head against a wall until I eventually figure out what went wrong, and I can put that time and mental energy into the stuff that’s actually interesting to me.
But yes, in general I do agree it’s kind of useless otherwise for creative endeavors or passion projects. It’s great for helping with code being written solely for a paycheck, but for personal projects it largely defeats the purpose of working on them in the first place. I think the trouble is that in general AI does make a lot of things easier and I have a lot of anxiety about getting into the habit of overusing it in that way, so I try to keep it as a sort of last resort.
That’s pretty accurate, but only the good case. Burnt out programmers still have some kind of system understanding and some kind of leftover appreciation for good software architecture, they’ve just been battered down by years of the stupidest requirements, deadlines and incompetent management. Even with AI they usually keep a hand on the wheel and aren’t particularly set on always using it for everything. Maybe they’ll even start advocating for AI because they can’t imagine anyone using it in a different way than they do.
The bad case is all the people who never cared about anything to begin with and aren’t any more emotionally attached to writing code than they are to filling out an excel sheet. That’s the kind of people that will absolutely derail an entire project by vibecoding it into the ground and then arguing for every single thing Claude changed. “You have to be able to understand/code this yourself” does stop them dead and they will piss and shit themselves because they can’t do anything and aren’t used to feeling stupid.Tbh I mostly like no-AI policies because it’s funny to see those meltdowns 🤷it’s crack for burnt out programmers who don’t enjoy the process of creating software anymore.
That explains perfectly my use of it for my job (where we’re expected to use it anyway). I’d been burnt out at my company for a long time, and LLMs give me the ability to at least still fulfill my feature quotas long after my desire to give a shit about the codebase and software had gone. I am a techmeth addict now. It kinda sucks, but I feel hopeless about tech as a career nowadays and just the future in general, so I don’t even care anymore.
It’s really weird when people with a kink try to push that kink on everyone else and they act like everyone else is wrong for building their entire persona around the kink. We get it, you really love hand crafting your code, line by line character by character, but I don’t need that to enjoy coding. I like producing useful things and then working on ways to make them even more useful. I have hand crafted enough widgets and thingamabobs that I don’t need to personally fondle another one into existence. I don’t need to be an expert at yet another language that will be obsolete well before I retire. When I was a young lad I could get off a really good wank to the bra section of the Woolworths catalog, but not so much anymore. That doesn’t mean I am burnt out or that I don’t like a good wank anymore, but frankly I would prefer someone with a pretty face and soft hands to yank on my dick for me. Have you never worked with or trained junior programmers before? I guarantee you that the nonsense a junior can produce is much worse than the crazed hallucinations of some AI.
There are a lot of reasons to hate AI, like the destruction of the dev experience pipeline… but shitting on people who manage to find ways to use AI is not really helping your crusade.
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.
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.
It just goes to show that ‘everything is only as strong as its weakest link’
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.
or consider not putting people on pedestals.
Big “100 physicists have signed a letter saying you’re wrong, Mr. Einstein” energy.
This also assumes that TootSweet is Einstein in this scenario, rather than just some guy on the Fediverse. If he’s got cred on par with Steve Yegge or Linus Torvalds the comparison might hold some weight, but I’m dubious about that.
No. Not that one.
There’s a story that a reporter said to Einstein “100 physicists have signed a letter saying your theory of relativity is wrong” to which Einstein replies “if they were right, it would only take one.”
Apocryphal or not, the point remains that truth is not a democracy. If a million people say AI is great, it doesn’t make it so — even if one of those people is the primary maintainer of the the Linux kernel.
And billions of people eat at McDonald’s, but that doesn’t make a hamburger better than a steak. Or any more ethical.
So… If AI were actually as bad as so many people are saying, it would actually only take one?
If people are saying that AI kills people and there was evidence that it did, then I would believe it.
This is still assuming that TootSweet is equivalent to Einstein here.
And is Linux equivalent to McDonald’s in this scenario? The analogy is becoming rather unclear.
No, it doesn’t assume TootSweet is Einstein.
It’s pretty sad that you seem to think that popular opinions are correct.
Plenty of popular opinions are wrong. And unpopular opinions are right.
The popular opinion is that AI is great at coding. But there isn’t much evidence that it is. There’s lots of evidence that it produces a lot of lines of code. Scant little evidence that it’s good code.
Hence the analogy to hamburger versus steak. They’re both beef, so technically the same. But hamburger is adulterated and watered-down. Steak is the real deal. So AI code is to real enginnering.
I pointed out that several smart people were disagreeing with TootSweet. You responded:
Big “100 physicists have signed a letter saying you’re wrong, Mr. Einstein” energy.
Who else would “Einstein” be in this analogy?
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.
He’s drunk the AI Kool-Aid.
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.
For me the most criticism against AI is rather criticism against Big Tech. AI itself however doesn’t have to inherently come from Big Tech so banning it wouldn’t really be reasonable for something like the Linux Kernel.
It doesn’t inherently have to come from big tech, but currently there’s nowhere else to get it, soooo…
Maybe we ban it now and then revisit all this after small open source local models are actually useful for anything?
Not true. I’ve been coding for months now using only local models running on my own hardware. It’s perfectly adequate with the right harness.
Ok well that’s actually awesome!! But is that what these people are using in big important projects like the Linux kernel, or are they using Claude? I’m guessing it’s the latter, right?
Local models are capable of assisting coding in even enormous, complex pieces of software. That’s where having the right harness really shines - it provides the model with the tools it needs to focus in on just the bits of code it’s currently working on. Sort of like how a regular human programmer can do a much better job working on a large project with Visual Assist or equivalent in their IDE. I’ve also installed some tools like Context7 that provides the LLM with API documentation (no more hallucinated APIs) or Firecrawl (it can just go search whatever it needs like a regular person). It’s not so great at large-scale architecture questions, but that’s not what 90% of coding usually involves.
If you want a step up from what can run on just commodity desktops, some of the bigger models are also open-weight and a company or studio with a programming department could run one of those on their own hardware in the server room. GLM 5.3 is right up there next to Claude in the benchmarks, for example, and doesn’t take a data center to run.
Or you could go halfsies on the “big tech” thing and have an API subscription for a big model that your coding harness uses for doing the large-scale architecture planning and then hands off to small local models for implementing the plans the big model wrote. That’s a very common pattern too.
The key point is that there’s a lot of options here, it’s not “pay Anthropic or nothing.”
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.
Linus being Linus :)
wow… his ego is pretty big and bursting. Good thing that he evacuated his brain power to LLMs.
deleted by creator
