why the highlights?

sigh. I think it's time to move to a BSD. Linus is gone.

There's nuance here though, LLM's actually do a better job of code that looks like it should work.

You get an unskilled junior in the mix, their code is obviously bad.

You get a semi decent LLM with a competent harness in there and you get a mix of code that works and code that nearly works.

There should be competent peer review either way, but the effort for each is potentially an order of magnitude different.

Then add on top that the LLM can churn them out way quicker than a junior could possibly achieve and you have a recipe for a huge review burden.

AI psychosis. Someone put him out of his misery. By replacing him I mean.

So he lacks empathy is what you are saying.

Can you elaborate on the last sentence a bit from a technical perspective? I'm not using code myself to the extent that I could really judge between LLM-generated code being good or just-works. I can just imagine compiler output being strictly deterministic, while LLM-code, due to the way a LLM works in principle, should be more ...unstructured?

I can run a compiler.

Then I can run it again, and the output will be the same.

I can run a LLM prompt.

Then I can run it again, and the output should not be the same. The unpredictability is what makes the tech great - Nobody in decision making actually understands this, but the goal is not for identical outputs. Just like me and you, don't respond to the same question in the same way every time

... is that people do their best and I expect people to understand what they are doing.

Except you can't with AI. It vomits a black box, and you have to decode it and test it before dumping it in a commit. Few do that.

People taking shortcuts is not new.

30 years ago when I was in school, cheating was rampant. There's going to be about 15-20% of people who understand when they are cheating themselves, and the rest won't and never have.

AI is really, really good at AHK scripts. Give it a shot.

stealing

Stealing: when you don't have it anymore afterwards.

Copying: when both have it afterwards

The RIAA's propaganda campaign was sadly very successful.

Feel free to fork the kernel for your ideology this is FOSS.

But isn't that exactly the argument of Linus? He says that the compiler is also a black box which vomits assembly.

Then the picture would be significantly changed if the cost of running useful LLMs goes down to what it costs to acquire a reasonable computer to work on the Linux kernel, no? That is if we could run useful LLMs for kernel programming on our kernel programming computers, and we own those LLMs. In such a world, capital would have no stronger leverage over us than it already does by selling us the computers we need to program. Does this argument make sense?

hes comparing knowing how open concepts work vs using proprietary tech whose purpose is to hook you and then enshittify after you become reliant on it

There is a difference with vibe coder that have no code background and software engineer that use LLM to generate code.

This situation is very similar to auto-completion IDE back in the days or more recently the first public version of Copilot.

AI don't vomit blackbox. It infere completely auditable transparent code (often with overdetailled comments). Maintainers do review the code that they will have to maintain before merging it in the main codebase. In FOSS they often don't care who you are, they are looking at the quality of your code, not your LinkedIn profile.

True. However the determinisim behind a compiler allows you to make some more solid assumptions.

For AI use you need to be a good chunk more careful to use it responsibly.

that is ... Debatable.

Yeah even writing lead to cognitive loss, because now people don't have to memorize everything.

It's just fear for the future and for change. And this is probably the most massive change in human history since fire was discovered.

But don't fear too much: the change is here and will stay, that's the only sure thing

Edit: what I mean is that accepting the fact AI is here and won't go away because we don't like it is the path to start regulating it at government level and agreeing on ethical rules to use it. Just saying you are a bad person of you use it it's like hiding under the sand. You lose.

You cannot, that's why reproducible builds are hard. Modern compiler are made with compilers (egg/chicken problem) not assembly nor machine code and you always loose some perfect prediction.

Yes LLMs are less predictible than compiler but their output is readable to human, while machine code is very hard (yet not impossible).

Is that a bad things that 99% of devs have forgot how to write code cutting holes in paper? Tools are changing and while a direct comparison between the move from paper to COBOL or assembly to C is not the same as python to LLM generated it's hard to deny that LLM will change how human write code.

Yes but unfortunately this specific tool is here to stay. Either we learn on how to use it properly and ethically and we regulate it, or we will be in deep troubles. Just denying and refusing to accept AI is here is dumb.

By regulate I mean at state and super-state level (not thinking of USA, but of the world) and define and accept proper ethical rules, both for individuals and corporations.

I got a stroke reading this.

I honestly didn't think you could even audit an LLM. It is possible, but not in the same way you would audit code. It is my understanding, because of the probabilistic nature of how the LLM operates, you can get different results even within the same model. This makes tracing something like logic next to impossible. Why the LLM gave the result is somewhat of a mystery. It is in effect a black box. This may change in the future, but for now LLM suffers from this issue.

Human slop code existed way before we had auto-complete in our IDEs, way before Copilot start writing small functions and thus bad code is not because of LLM. AI slop is no different than Human slop, it uses a shit ton of ressource to generate it and is faster at getting a working output but bad codebase is not new.

You can get the same output from the LLM if you put the appropriate guardrails and context in place. That's what is happening in the enterprise space.

But why can you not audit what the LLM creates? You can't do it for the general case, i.e. prove that for a given prompt it always spits out a valid solution, but you can look at what it actually spit out for your concrete prompt and then you can freely decide, if those code changes are good.

I am of the opinion that a thorough review often takes similarly long to actually writing it yourself, and there's a high chance that you miss architectural aspects, if you don't investigate yourself.

But yeah, again, I think you're taking the comparison too literal.
He is just saying that LLMs are a tool. You need to know how to use your tool and produce objectively good results. Then he does not care what tool you use to get there.

Thanks for that explanation. Are you saying that if I rebuild the exact same code on the same machine I could get different results for a given compiler? I think this would render solutions like docker useless. Could you elaborate?

If I ask "why did the LLM output "for" as the XXXXth word of its utterance, can Linus say why?

If you have the model that was used, and the seed used for the generation, then yes you can trace the weights and figure out how everything was generated.

AI is deterministic. And compilers can be just as "nondeterministic" if you don't know what compiler was used and what flags were enabled.

For local LLMs you can set the seed and generate the same output every time.

Auditing typically means tracing the logical path. How do you suggest to do this with an LLM?

I am definitely taking his words literally which is why I disagree with just this one point.

Yes you can get a different result. Compilers are designed to be deterministic, but a build is more than the compiler. Usually the bytes differ but the behavior is identical.

Docker is far from being reproducible!

It works on my machine ≠ reproducible.
But reproducible will make it works on your machine.

Using a compiler does not guarantee you to get byte-perfect output each time, especially not on different machines.

One should look at China when they're concerned about the USA approach.

I can think of plenty of tools that will do something for you even if you understand nothing about the tool, how it works, or the domains it is helfpul with.

I can plug a drill in a socket, put a random bit on and drill a hole without any knowledge of how a drill is supposed to work. But my hole won't be straight, will be too deep ir too shallow, too large or too small, and I might have drilled straight into a pipe. I don't understand how drilling works, I still drilled, but the outcome is shit.

I can mix a bunch of flour, eggs, sugar and chocolate in a bowl, then put it in an oven at max temperature on a random heat method and wait half a day. I'll have a bunch of coal, not a cake. I used an oven without any idra how an oven works, it did something for me. It's shit, but it did something for me.

Anyone can put the key in a car and start pressing random pedals to figure out how it works. Eventually anyone will get it... If you're not dead before then or you didn't total your car. Without understanding anything about a car, I did manage to move it and go somewhere. But I damaged some things in the way.

I could go on and on with as many tools as you want. But I doubt you'll keep reading.

LLMs in software development are the same: If you understand how to steer it, if you understand software engineering, it will have fantastic results. If you don't, it will have shit results. The only difference is that it is much harder to understand the insides of how an LLM model works, as that is another specialty. But just like you don't need to understand how an oven actually works to use it, you don't need to understand how an LLM actually works to use it.

Edit: Another great example is a camera. Anyone can take a picture, but without a good understanding of photography, most people's pictures will be shit. And the vast majority of users do not understand and do not hace the knowledge to understand how a camera works.

Sleeping agent in LLM is a scary topic and the tech itself has mathematically no solution for this: https://arxiv.org/html/2401.05566v2

That blog post is just a bunch of insults to anyone not agreeing with the writer without actually giving any elaborate or truthful argument on why is not just a tool and it's always inherently "evil".

Some arguments made can be easily disproven. For instance the climate change one.

They main point of the post is that "no matter how you use LLMs". But then the argument given here it's highly dependant on how you use them. The amount of environmental damage of LLMs completely depends on which LLMs you use, how you use them and how often you use them.
This just here it's showing the irrationally of the blog author.

But it goes one, next point is economics. Which is also 100% dependant on HOW YOU USE IT. Not all LLM are made by big evil corporations, and there's nothing in the technology preventing it being made by anyone.

For a blog post whose main argument is that saying "it depends how you use it" is wrong, have only give arguments that are dependant on how you use. The author makes broad ignorant assumptions about how people use LLMs, asserts that everyone uses them like that and then pretends to control everyone lives based of that. That way of thinking is highly dangerous and it's what have given birth to a lot of evil on our world. We need to be better, more rational, more open minded. Not falling for easy politics and actually do complex political thinking that won't give simple answers to complex questions.

Yes, that is a great explanation. Thank you.

That is, of course, the whole point of docker (making sure the results of compiling are identical). I totally get the different machines giving slightly different results. This is not really in the same realm of the dramatically different output a LLM will give though.

AI use demonstrably leads to cognitive decline.

No. AI is simply too recent and evolves too quickly to be demonstrably anything.

The studies you refer to are mostly flawed, and most importantly not about software engineering, where I assure you the problem solving part is not diminished, simply shifted. Don't let the memes that show people type "just do your best bro" into claude code influence you, they are just memes :)

"Y-y-yeah well. If you like em' so much why don't you marry em'! Hehe got em'"

Please let's try and keep this above middle school. The whole point here is that comparing people who fundamentally disagree with this tech as "Luddites" or "Amish" betrays a lack of understanding of those two groups of people.

That's a dishonest example. The output of an LLM is never a copy of someone else's work. That's not how it works.

If you edit a photograph, then yes, it is your work, not as a photographer, but still your work. Even though you didn't edit the pixels one by one.

No the goal of Docker is not to make sure the results of compiling are identitcal. It is to make it work on your machine, there is some nuance to it.

This is more the goal of something like nixpkgs (NixOS).

This is not really in the same realm of the dramatically different output a LLM will give though.

Yes this is not same realm but my point was that eve if LLM would give you different results each time the result is transparent and editable. Also developers tools evolve and Linus have more technical knowledge to use this tool in a way that will gave him satisfying result than me or a junior dev with 1.5 years of experience. He was against LLM generated code a few years ago, not because he hated on AI but because this tool was giving him unsatisfiying results. If compilers were not working 50% of the time he would probably write everything in assembly. LLM models and their coding harness cannot be compared to what they were 2 years ago. And most of the devs are using them. Will that transform bad devs into good ones? Probably not. Does that mean that LLM generated or assisted code is the way to go? Not necessarly. But it means that it's a tool that find its use in the majority of development teams and thus that they find it quite useful.

There is some issues with it and I'm not here to deny them. Whether they are social, environmental, capitalist, monopolist, learning. Like every new disruptive tool we use them in ways we won't in the future and I think it's similar with AI.

Can't help but laugh at you guys correcting literally the undisputed #1 software maintainer in the world. AI is just a tool - if you fail then it's a skill issue.

Bye

What's the point of this argument though? Sure it's real for every profession and every tool but what's the agentic choice we ought to pursue here? Whine against AI or actually lead society with policy? As "ban llm" is not a valid policy that would ever work so the only viable path is regulation and growing of culture where AI is used for good, no?

Embrace AI, work towards open weight/free software and protect worker rights. Society wins at the bleeding edge not at conservstism.

You don't have to do everything with the LLM. Tracing the logical path very much still happens by looking at the code in your editor.

This is also why I'm saying it isn't much faster. Understanding the existing code and what changes are necessary is the bulk of the work when handwriting code as well.

You *can* tell the LLM to go ham and implement the change on its own and then only look at the diff afterwards, but anyone who thinks they understand the code changes then, is lying to themselves IMHO.

It’s fine to see Linus as a demi-god amongst programmers, but to think whatever he says is indisputable is just foolish.

It turns out I agree with his point-of-view here, but his is not the only valid one, and there is no way to evolve arguments and ideas without challenging them.

Armchair psychologists everywhere

Now with remote diagnosis

Linus is well-known for edgy and controversial points. He's undoubtedly a great programmer, but ultimately, he's human.

fork the kernel

And find like at least a hundred extremely competent devs to maintain it, and a thousand devs to review the code.

Because weight x = y isn't really a satisfactory answer to the "why" in question though. To really answer that you need to refer to the pretraining and context, which in a lot of cases today, and likely forever, since there's no reason for anyone to cold start model training ever again, is necessarily opaque. A lot of the best why answers are going to be given by the model itself (which... obviously circular). Trust and attribution are just really hard in this paradigm. Not necessarily so different from the challenge of trusting/attributing human output, except that humans are more diverse and in general difficult to manipulate.

Based.

You're right, I said "steal" as it was the most common word, the right one was "exploiting". Fixing it.