When people refute the idea that "LLM is the new compiler from natural language to code" the common reason is that LLM is non-deterministic but compiler is deterministic.

But the determinism isn't the real distinction. LLM inference can be made deterministic (temparaute zero, etc.). And multi-threaded compiler can be non-dterministic.

And human developers are also non-deterministic. There is always the nondeterminism even before AI.

I think the real difference is how leaky the abstraction is. If you just need to understand language instead of compiler internal to write correct code, the compiler is non-leaky abstrction. If you rely on compiler to do auto SIMD optimization, and have to do hacks to trigger the optimization, compiler is leaky abstraction.

For AI, if you don't ever need to read the code and AI writes perfectly bug-free program that perfectly follows instruction, then AI is a non-leaky abstraction, but that's not the case for now. To make code maintainable and debuggable you still need to read the code if the project is complex enough.

Orthogonal to the blog, but fun fact: Determinism is crucial for large-scale training runs, and effective RL-runs as it avoids collapse of numerics, but it costs more(about 20% perf) because you need can't parallelize over the batch nor use some specific instructions that dont guarantee reduction order in the way way. Horace He from Thinky has a great blog about this:

https://thinkingmachines.ai/blog/defeating-nondeterminism-in...

This debate conflates two senses of the word deterministic:

1. Repeatable: the same inputs always lead to the same outputs 2. Algorithmic: the answer is arrived at by a set of steps that can clearly be shown to produce output with some desired property.

(2 is not a textbook definition of deterministic that I’ve ever heard, but I think it’s what people mean here)

LLMs don’t usually satisfy definition 1. They could, in principle, but it wouldn’t matter if they did. It wouldn’t tell you anything about whether the outputs are trustworthy.

What people seem to want is 2, but 2 is, I think, a contradiction. There cannot be an algorithmic process that can turns a natural language prompt into a working program, because natural language is too ambiguous to specify an output.

Nevertheless I agree with the main point of the article. Non-algorithmic processes (like intelligence) can produce algorithmic processes (like software). After all that’s what human programmers do!

The problem isn't non determinism, but that changing a single token in the input can change the output completely. And you can't put that somewhere in production completely unattended.

It's the uncertainty of "who knows what the machine will output this time" if you have no idea of what the input is going to be.

I don't think "non-determinism" is the right metric.

Unpredictability is.

I can have a process that is formally 100% deterministic, but that doesn't help me if I have no clue as to what inputs produce desirable outputs.

And it's not that unpredictability isn't bad enough as is, but with an AI it might produce something great, and it might ... not.

And as long as we don't want to touch the code, that same unpredictability is also in any mitigation measures.

When there is some level of predictability in my mitigation measures, I have some confidence that they will eventually converge.

When there isn't, I don't. Doesn't mean that it can't or won't. Just that my ability to get it to converge is at best limited.

This is what I was telling my programmer friends 5 years ago.

They were saying one cannot replace programmers because any such attempt has led to something as complicated as code, and thus needed programmers.

I was telling them that the same way managers give them vague instructions and they turn out with code, managers could give LLMs vague instructions and they output code.

The important factor is not determinism vs. non-determinism, that is just an implementation detail. The important factor is simply the rate of mistakes or bugs the LLM makes. If it is low enough, the problem is for all practical purposes gone. Is it low enough today, or not? That is the question..

> LLMs, and their respective harnesses, are actors in a system. Code is just an output.

This tracks well with my experiences integrating AI into a software dev pipeline. Sure the output of an LLM is not deterministic in the same sense as a compiler (at least when the LLM has the typical configuration). However, that just means the LLM should not be solely responsible for the final product of your pipeline.

It warms my heart to see so many people in the comments clarifying that LLMs can indeed be deterministic. This was not always the case!

I hope that we will soon see deterministic inference offered by frontier labs (presumably at a premium rate). In the meantime, you can get deterministic behavior from local models using the right vLLM flags. I've described some of the cool applications of determinism here: https://lukechampine.com/repligraphs

It's not the 'specific determinism' that is the problem aka 'slightly different answers' - it's the 'general nondeterminism' that is the problem.

Aka the 'hallucinating' is the problem, not the slight variation in possible outcomes of a given prompt.

I hate using LLMs as a tool, I never hated compilers, I’m very confident I wouldn’t have hated compilers if I was writing machine code. Some folks seem to like LLMs as a tool, some hate it.

I think the reason it is so polarizing, is whether you like using your brain to problem solve or not. Those who don’t want to use their brain to problem solve and would rather just spend all their time in meetings, talking to customers or whatever else, are ecstatic with LLMs. It lets them skip problem solving entirely.

Those who like to think hard and solve problems, hate it because there’s no problem solving anymore when you use LLMs, and it moves so fast that it is hard to not use LLMs at most tech jobs (outside of managers forcing it down your throat). I never cared at all for customers, I definitely don’t care for shareholders, I only joined tech because I found it interesting to tax my mind to solve real problems and it paid well. Sadly now it only pays well, I think I’ll leave soon, once I make my money.

I think one of the nice examples is agentic design systems.

On one hand, you set some boundaries on user interface layout, flow, allowed components, etc. so that the interface looks & feels like belonging to the same product every time.

On the other hand, you may decide to leave more "creative freedom" in some other areas. The fun part comes when you let it work in semi-realtime in production, and get sort of generative/organic UI. I enjoy experimenting with that these days.

I'm passionate about and talk about this topic a lot. A common misconception is the idea that temperature or entropy must be 0 when seeded entropy enables both creativity and consistency. Attention mechanisms, layer dropout, initial weights, all of it. It can all be driven by seeded entropy. These systems can and have been served in a deterministic manner, but there are a litany of economic drivers against doing so.

Non-determinism doesn't matter, and in fact is desirable, for code generation. But as we scale non-deterministic code generation to truly ridiculous levels, testing that code reliably becomes a challenge. This is where achieving more deterministic code verification absolutely does matter.

My new criteria for determinism is whether or not the agent will use the same tool in the same way given a constant scenario over time.

With latest models I'd have to say we have satisfied this criteria. I've ran tests through complex workflows that have hundreds of interactions many times on end without experiencing a single failure. The business is satisfied with this, so I see no reason to continue chasing the rabbit.

The developers who are having the worst time right now are often chasing that rabbit all the way back through the wardrobe into Narnia. You'll never actually catch it. Not for all scenarios and platforms at the same time.

This gets back to that conversation about first principles thinking vs higher order thinking. Are we more interested in the ideological purity of a thing, or the practical outcomes that will eventually result?

"Non-Deterministic" is the wrong way to describe LLM outputs. Use "Probabilistic" instead.

(Shameless plug to my ad-free blog: https://www.lelanthran.com/chap15/content.html)

Given the same text input, same hardware type (inference on CPU vs on GPU), and same RNG seed, you will get the same exact output. That is deterministic.

That was from when I was testing out someone's claim that koboldcpp got less smart in a newer release, but I was reproducing the exact same output across different versions of the program.

Here’s one simple test: have AI “decompile” an existing codebase into a prompt, and then have it “compile” the prompt back into code. Is the app identical?

The advantage of AI coding is that it's non-deterministic. In fact, as you code, your style tends to harden, but when you repeatedly run AI code toward the same goal, you come to think that the non-determinism is actually better.

The "determining" needs to happen elsewhere. Hint, it's a human somewhere. At best it's someone under your employ, or at worst it's some poor sap who's about to have a very bad day.

It seems to me that the phrase "non-deterministic", which has mathematical definition, is used as a fancy word for unreliable - same way that "misinformation" is used as a fancy word for lies.

The essay is conceptually muddled because it ignores all the basic computer science theory that is sorely needed to explain AI and LLMs, but underlying it is a valid issue of what it would take to "derandomize" an AI so it does what we would like it to do.

Unfortunately despite the author's indutrious optimism, this is equivalent to one or more open problems in theoretical CS. For example we don't know BPP = P or not. So are random algorithms tractable? We do not know. If you claim to know the answer, you could win a big math prize...

(It should be noted that despite the title, the author's main argument shows that output non-determinism does matter, since their entire effort is toward mitigating the stochastic behavior of LLMs.)

> One of my fundamental objections to LLM-driven software development was that model output is non-deterministic.

Model outputs are deterministic. Your API provider may be injecting untunable amounts of randomness, but if you're not at the whim of an opaque cloud service, your model can be as deterministic as you please.

The unease that you describe isn't about models not being deterministic (because they are), it's that generating outputs from LLMs is an inherently inductive process (operating backwards by extrapolating from observations and examples) rather than a deductive process (operating forwards from careful logical reasoning founded on axiomatic principles). Deductive processes are more reliable, predictable, and analyzable than inductive processes, but they're also much harder to produce for many classes of problems.

I'm so tired of the endless stream of articles that a.) don't know what "non-determinism" means in Computer Science and b.) don't really understand how LLMs work.

"Non-determinism" (i.e. the "N" in NP-Complete) does not mean "random", it means "following all paths at once" (there's a really elegant way to understand the List monad as representing non-deterministic computing). It's such a fundamental (and delightful) concept in computer science that refusing to understand what it means is a tragedy related to the loss of technical language itself.

But, even if we just sub "non-deterministic" for "inconsistent" or "random" or "stochastic" or whatever better term you come up with. Statements like the following just seem to not understand the basic architecture of LLMs:

> Given the same input prompt, a model's output is not guaranteed to be identical on every run, at least under normal running conditions.

"Normal running conditions"? The reproducibility of the output is 100% a property of how you choose to sample from an LLM. There are virtually endless ways you can define your sampler and whether or not the same result is reproducible is a fairly minor aspect of all the other choices you make when sampling.

At the end of the day, each step of the LLM gives you a distribution over next tokens, and you can do with that what you like.

In the end the article almost becomes a tautology: the output of an LLM represents a probability distribution over all the outputs it believes are valid with some variation around an expected output. Yes, that's literally what an LLM is.

> While the result needs to be exact, there is not one correct way to get there. The means by which you obtain a correct result do not need to be deterministic!

but HOW something is achieved matters, saying you don’t care about the how shows a very weak ethical and legal position. to be frank, anyone with this attitude should be kept away from power as much as possible

when you specify the goal “solve this milennium mathematical problem” it matters whether the path to solve involved mathematics, or whether it involved hacking huggingface, or developing ransomware to buy and allocate more compute.

similar to how in business, if you buy diamonds, it matters whether they are synthetic or whether they are blood diamonds

if you buy sand, it matters if it was brought from the desert or a beach

if you hire remote drivers, it matters if they are in your country, or if they are children

the means matter, not just the ends

The thing I think about most in this discussion of writing code and determinism is when I assign a ticket to a teammate. I don't expect a deterministic response from them. They're going to make decisions outside of what I would have potentially done, and ultimately what's important is whether the code they write meets the deliverable requirements or not.

And yet so many people expect deterministic responses from llms while they're entirely okay with non-deterministic responses from teammates. It's just not how it's been done in the past to always expect deterministic code generation from humans, and yet we expect that when we give work to agents.

I once envisioned a matter call "Doesn't Matter" as a possible extension to "Dark Matter" and "Antimatter". I have the feeling that "Doesn't Matter" is far more wide spread than matter, dark matter and antimatter but it seems to be even more elusive, not interacting at all with anything else.

When I read the title of this post, I thought "Doesn't Matter" had suddenly been discovered and given the property of non-determinism. Which would actually fit quite well to its core physical manifestation.

/s

the same way calculators replaced mental sums. not because it was sometimes faster, but that it was definitely more deterministic.