9 ms·
LLMs Are Not a Higher Level of Abstraction
- jqpabc123 6mo agoIn other words, LLMs are probabilistic, not deterministic.
- sscaryterry 6mo agoDare I say, so are humans?
- jqpabc123 6mo agoThis used to be a big reason why we used computers --- to help eliminate the probability of error. But apparently, not so much any more.
- somewhereoutth 6mo agoRight, it was the perfect match: Humans for fuzzy touchy feely stuff, computers for hard edged correct calculations. How have we managed to screw this up so badly?
- irishcoffee 6mo agoI think the big unmentioned elephant in the room is the gambling/dopamine aspect of using an LLM. It’s to the point where people at $dayjob joke about it… but they’re not joking. That’s how it got screwed up so badly. We have a bunch of engineers paying money to open loot boxes and they get visibly upset when they run out of tokens. LLM companies have done an absolutely brilliant job of figuring out how to burn more tokens quickly, couch it as “more advanced” and people throw money at them. I realize this wasn’t the thrust of your point, but tangentially, we fucked it up so badly because people desperately want to ignore this bit, and instead of looking at these tools analytically, there are the ardent defenders and the staunchly opposed… much like every other topic under the sun these days. I use the free stuff work pays for, and I’ve never hit any token limit or anything like that. But I’m also trying extremely hard to ensure my skillsets don’t atrophy. I just use the web interface and ask questions. I have no interest in tying my development experience directly into an LLM, not after what I’ve seen at work over the last few weeks.
- somewhereoutth 6mo agoGambling is right. And not just the dopamine, habitual gamblers remember the wins and forget the losses, so tend to believe they are 'ahead'. In time the bean counters will come and sober everyone up, the bottom line can't be argued with.
- jqpabc123 6mo agoIn time the bean counters will come and sober everyone up Lawyers are going to be involved in this too.
- mpyne 6mo agoDigital computers were named after the humans whose jobs they automated out of existence. They were invented to reduce cost of computation, not to eliminate the probability of error per se. Ask a Windows 11 user, they'll tell you computers still make errors.
- card_zero 6mo agoNo, I'm pretty sure it does it on purpose.
- suttontom 6mo agoAt this point this argument has crossed over into whataboutism.
- kibwen 6mo agoDeterminism is a red herring here. The problem is that LLMs are inductive systems, not deductive systems. This makes them powerfully general, and yet inherently unreliable.
- cyanydeez 6mo agoThis makes sense, but you need to understand that you're ignoring the compiler once you're past the machine code level which isn't an abstraction right, it's the root. So ignoring that part of the missive, goin from C to Python, different compilers do add different machine code. C and Python have a bunch of different compilers, so you don't if you take the same code, the f' output can be different. There's determinism within the same compiler. Add in different architectures, and the machine code output definitely is more varied than presented. But that's still a manageable; then what if you add in all the dependencies, well you get a more florid complexity. So really, it's a shitty abstraction rather than an inaccurate analogy. If you lined them up in levels, there could be some universe where they are a valid abstraction. But it's not the current universe, because we know the models function on non-determinism. I'd posit if there was a 'turtles all the way down' abstraction for the LLM, it's simply coming from the other end, the one where human mind might start entering the picture.
- bigstrat2003 6mo agoYou're right, but the reality is that the people who are excited about LLMs don't care about determinism. They are happy to hand off the thinking to a third party, even if it will give wrong answers they don't notice.
- archagon 6mo agoThen they should not pretend that they're still "engineers" working on a higher level of "abstraction".
- conorbergin 6mo agoLLMs are deterministic, the same model under the same conditions will produce the same output, unless some randomness is purposefully injected. Neural networks in general can be thought of as universal function approximators.
- 0-_-0 6mo agoYou're being downvoted, but you're right. Determinism is a different concept and doesn't characterise LLMs well. You can have deterministic random number generators for example.
- alansaber 6mo agoYes theres a good thinking machines lab blog about this
- 2ndorderthought 6mo agoThat's not really true. If you turn a few knobs you can make them deterministic. Namely setting temperature to zero, and turning off all history. But none of the cloud providers do this. Because it's not a product as far as they are concerned. So in practice - not so much.
- maplethorpe 6mo agoCan someone explain why this is? Do LLMs somehow contain a true random number generator? Why wouldn't they produce the same outputs given the same inputs (even temperature)? edit: I'm not talking about an LLM as accessed through a provider. I'm just talking about using a model directly. Why wouldn't that be deterministic?
- 2ndorderthought 6mo agoYea sure. So temperature is baked into these LLM models and when it isn't zero it increases the probability of taking a different path to decode the tokens. Whether it's at a provider or downloaded on your own machine. Technically even when the temperature is 0 it's not deterministic but it's more likely to be... You can have ties in probabilities for generating the next words. And floating point noise is real. All these models are doing is guesstimating the next token to say.
- legerdemain 6mo agoThis is absurd. The author misrepresents the type of "abstraction" that people mean. This abstraction ladder goes as follows: - contributing individually - contributing as a tech lead - contributing as a technical manager - leaving the occupation to open a vanity business, such as a gastropub or horse shoeing service
- maplethorpe 6mo agoAbstraction has a specific meaning in computer programming. I don't think he's misrepresenting it. https://en.wikipedia.org/wiki/Abstraction_(computer_science) https://en.wikipedia.org/wiki/Abstraction_(computer_science)
- LeCompteSftware 6mo agoOP is being a bit tongue-in-cheek, I believe they mean that some vibe coders really want to be abstracted away from their own jobs, and are very much not interested in computer-scientific abstraction.
- maplethorpe 6mo agoOh.
- dimtion 6mo agoI'm not sure why people struggle with the fact that an abstraction can be built on top of a non-deterministic and stochastic system. Many such abstractions already exist in the world we live. Take sending a packet over a noisy, low SNR cell network. A high number of packets may be lost. This doesn't prevent me, as a software developer, from building an abstraction on top of a "mostly-reliable" TCP connection to deliver my website. There are times when the service doesn't work, particularly when the packet loss rate is too high. I can still incorporate these failures into my mental model of the abstraction (e.g through TIMEOUTs, CONN_ERRs…). Much of engineering and reliability history revolves around building mathematical models on top of an unpredictable world. We are far from solving this problem with LLMs, but this doesn't prevent me from thinking of LLMs as a new level of abstraction that can edit and transform code.
- distalx 6mo agoA transmission error has a strictly contained, predictable blast radius. If a packet drops, the system knows exactly how to handle it: it throws a timeout, drops a connection, or asks for a retry. The worst-case scenario is known. A reasoning error has an infinite, unpredictable blast radius. When an LLM hallucinates, it doesn't fail safely but it writes perfectly compiling code that does the wrong thing. That "wrong thing" might just render a button incorrectly, or it might silently delete your production database, or open a security backdoor. You can build reliable abstractions over failures that are predictable and contained. You cannot abstract away unpredictable destruction.
- yunwal 6mo ago> A reasoning error has an infinite, unpredictable blast radius. Says who? It’s quite easy to limit the blast radius of a reasoning error.
- amazingamazing 6mo agoHow so? Suppose you had: Math() Add() Subtract() Program() Math(“calculate rate”) This is intentionally written vaguely. How do you limit that these implementations ensure Program() runs and does the right thing when there is no guarantee Math() or its components are correct? Normally you could use a typed programming language, unit tests, etc, but if LLM is the ultimate abstraction programs will be written line above. At some point traditional software engineering principles will need to apply.
- yongjik 6mo agoIt's orthogonal to whether LLMs can be a useful abstraction layer, but ... I have a feeling that if LLMs were built on a deterministic technology, a lot of the current AI-is-not-intelligent crowd would be saying "These LLMs can only generate one answer given a question, which means they lack human creativity and they'll never be intelligent!"
- byzantinegene 6mo agoit is a fruitless endeavour to try to appeal to a crowd that does not and will never understand the fundamentals of how llms work.
- xpct 6mo agoInteresting. I believe some circles reached the consensus that they aren't creative, but that it's independent of their intelligence/modelling capabilities.
- xigoi 6mo agoIt’s not really about determinism, but about the fact that the input to an LLM is inherently ambiguous, unlike the input to a C compiler.
- madisonmay 6mo agoLLMs are not inherently non-deterministic during inference. I don't believe non-determinism implies lack of abstraction. Abstraction is simply hiding detail to manage complexity.
- danpalmer 6mo agoNon-determinism is configurable at the level of the mathematical model, but current production systems do not support deterministic evaluation of LLMs.
- orbital-decay 6mo agoThey do, though. Providers don't because batching makes it cheaper. Among the providers, DeepSeek seems to support it for v4 (and have actually optimized their kernels for batching), and Gemini Flash is "almost deterministic".
- danpalmer 6mo agoI'm pretty sure that the determinism issue is at the floating point math level, or even the hardware level. Just disabling batching and reducing the temperature to 0 does not result in truly deterministic answers.
- orbital-decay 6mo agoFP math itself is deterministic on real hardware, if the order of operations stays the same. Output reproducibility is much less of a problem than it seems, see for example https://docs.vllm.ai/en/latest/usage/reproducibility/ https://docs.vllm.ai/en/latest/usage/reproducibility/
- nnevatie 6mo agoThe FP math is deterministic. However, the environments in which inference is run and specifically batching make current LLM services practically non-deterministic.
- calf 6mo agoThere are a few things being confused because people are having to learn/re-learn/re-discover basic computer science classes, but both formal specifications and informal specifications - such as pseudocode (I balk imagining how many AI users might not know this term), or natural language documentation - are all forms of abstraction. Programming languages and underlying models of computation all enable varying degrees of hiding details or emphasizing important ideas/information. Human thought and language, and mathematics, are already examples of abstraction in general. LLMs thus also purport to provide a (via computational model alternative to Turing machines) higher kind of abstraction, the debate is whether it is a good one, if its hallucinations make it unreliable, etc.
- Legend2440 6mo agoI don't agree with this take. Determinism is a nice property for abstractions to have, but it isn't necessary to be an abstraction. And LLMs can handle very abstract concepts that could not possibly be encoded in C++, like the user's goal in using software.
- farmdawgnation 6mo agoI think you could also make the case that the existing abstractions aren't actually fully deterministic themselves. The compiler or interpreter may not behave as it should. Therefore, for any correct C code, there's probability that the GCC compiler will turn it into correctly formed machine code. But it may not! Is the probability much higher with GCC? Sure. But it's still a probability.
- anon-3988 6mo agoI am sorry but this is an insane take. The probability of GCC going haywire with your special snowflake correct C code? Please. Have this EVER happen to you? I am not talking about the performance of the generated assembly because that IS flaky, but functionality wise I do not think so. If people are so confident about the determinism of LLMs, or at least consider it on par with compilers, please ask it to compile your source code instead. Better yet, replace all your GNU utils with LLM instead. Replace your `ls` with `codex "prompt"`.
- elwebmaster 6mo agoI have done this, alias codex --yolo -p . It's very helpful not having to remember every odd command and its parameters. It's a bit more typing but I type faster than invoke and scan through man pages.
- hirako2000 6mo agoThey are deterministic. Including in the way they fail.
- 6mo ago
- deleted 6mo ago[deleted]
- royal__ 6mo agoI agree, but I think it's for a different reason than what the author says: LLMs are a very leaky abstraction compared to other levels, meaning it's much harder to convey the true intent of logic you are trying to encode through natural language, and often by doing so you are just relying on the LLM to "get it right", which is inherently messy business. Oftentimes, that leakiness just doesn't matter that much. Other times, it does.
- jefurii 6mo agoI don't feel that this piece explains its title very well (to me) though the idea expressed by the title is spot-on I've gone through hand-coding HTML, CGI, CMSes, web frameworks, and CMSes built with web frameworks. Each is (roughly) a layer of abstraction on top of lower layers. People talk about LLMs as an extension of this layering but they're not. With the layers of abstraction I've listed you can go down to the layers underneath and understand them if you take the time. LLMs are something different. They're a replacement for or a simulation of the thinking process involved in programming at various layers.
- DauntingPear7 6mo agotheyre like an advanced form of program synthesis. Something that operates outside of the abstraction layering.
- dakial1 6mo agoYour point is similar to the post in a sense that all abstractions are deterministic, so you could go connect the higher layer directly to the lower layer, while in LLMs, by their very probabilistic/black box nature you can’t have this direct link. But isn’t this just a semantics discussion? Is there a rule for abstraction in CS that says it needs to be deterministic (I really don’t know)? I believe deterministic abstraction to natural language is impossible to reach by the very ambiguous nature of it, we get misunderstandings when we talk to each other so naturally when talking to a machine it would need to be probabilistic to understand how to translate it to code.
- ofjcihen 6mo agoTangential to the subject matter but has anyone else noticed that night time tends to have more people arguing that LLMs are intelligent and the daytime tends to have more arguing that they aren’t?
- taraharris 6mo agoThe claim is that compilers were f(x) -> y, and LLMs are f(x) -> P(y | z1 | z2 | ... z3). But how were various combinations of popular programming languages, operating systems and hardware platforms not effectively f(x) -> P(y | z1 | z2 | ... z3)? Suppose you were quick on the take and were writing in Unix and C in the early 80s and found yourself porting your program from a PDP-something to an 8088 PC, or to a 68k Mac, dealing with DOS extenders, printer drivers, different versions of C (remember K&R style?) or C++? Remember MFC? The evolution of the STL? LLMs are similar to that maelstrom, just on a faster timescale.
- hirako2000 6mo agoThe difference is that you can port f(x) -> y To be exactly that. To any target that exists and to come. An LLM can't. Even within your primary target. It's like explaining how a hammer isn't a screw driver. And someone comes to argue the fact that a hammer too, can break.
- samstokes 6mo agoI wouldn't agree that LLMs are a higher level of abstraction, but I've found they do help me think at a higher level of abstraction, by temporarily outsourcing cognitive load. With changes like substantial refactors or ambitious feature additions, it's easy to exceed the infamous "seven things I can remember at once": * the idea for the big change itself * my reason for making the change * the relevant components and how they currently work * the new way they'll fit together after the change * the messy intermediate state when I'm half finished but still need a working system to get feedback * edge cases I'm ignoring for now but will have to tackle eventually * actual code changes * how I'm going to test this Good lab notes, specs etc can help, but it's a lot to keep in mind. In practice these often turn into multi person projects, and communication is hard so that often means delay or drift. Having an agent temporarily worry about * wiring a new parameter through several layers * writing a test harness for an untested component * experimentally adding multibyte character support on a branch frees up my mental bandwidth for the harder parts of the problem. The main benefit is to defer the concern until I have a mostly working system. Then I come back and review its output, since I'm still responsible for what it delivers, and I want better than "mostly working".
- conradludgate 6mo agoThis is what I've found to be very successful for me. My flavour of ADHD has historically made it hard for me to start new projects as I get very stuck on all of the little details from the start, while also thinking about the high level aspects. Being able to spend my energy on the architectural decisions and validate my understanding before spending time on optimising the internals has actually allowed me to follow through with some of my designs. Experimentation is then faster. If the data model wasn't good enough, I can actually experiment with it immediately, before we accidentally ship something to production and then have to deal with a very annoying data migration problem. The exact code doesn't matter to begin with when we just want to make sure the data is efficient to decode and is cache friendly. I recently built a project I had in my mind for 3 years but could never work on because all the individual components were overwhelming. It involved e2e encryption, consensus, p2p networking, CRDTs, and API design. It was very nice to see it come together. The project ended up failing due to some underlying invariant, so it was nice to validate that and finally get it out of my head.
- dpark 6mo ago“Each move from one layer of the tech stack to a higher one involved a function: f(x) -> y Given a specific x, you always get a specific y as the artifact being generated.” Not at all. If this were true then the Python code in question would generate deterministic binary. Of course that’s not what happens. The Python runs through an interpreter that may change behavior on different runs. It may change behavior version to version. It may even change behavior during multiple invocations of a function in the same running instance. Because all of that is abstracted away. Same for the C code. You give up control and some determinism for the higher abstraction. You might get there same output between compilations on the same version but that’s not actually guaranteed and version to version consistent certainly isn’t. Moving to a higher layer of abstraction very often results in less constrained behavior.
- slopinthebag 6mo agoCan you explain how Python or C programs change from invocation to invocation?
- dpark 6mo agoMostly because the behavior is implementation defined. So long as the behavior meets the contract, the compiler/interpreter is free to do whatever it wants. Python could certainly optimize repeated code paths to make them more efficient. I don’t know that the standard implementation actually does, but it could. Spending extra time optimizing repeated code paths is a reasonable choice for an interpreted or JIT compiled language. I would not expect C to change from invocation to invocation mostly because C is supposed to be boring and predictable. That’s kind of its thing. But again, it could. There’s nothing in the C spec I’m aware of that says the C compiler has to ensure that each invocation of a piece of code will execute the same machine instructions.
- slopinthebag 6mo agoOk but how does that change the behaviour of the program?
- UltraSane 6mo agoThe exact code might not be deterministic but the behavior can be if your spec uses something like Dafny or TLA+ and is detailed enough
- kusokurae 6mo agoReally anything can (and must) be written to justify delegated thought. See: replies to this thread.
- DauntingPear7 6mo agoI don't think they fit in as a layer of abstraction, but instead are outside of it. An abstraction simplifies away the inner workings of what is being abstracted. The LLM exists outside of your code. It is not part of it, thus, it is not abstracting it away. If this were the case, a coworker would be an abstraction to code they own (you could argue this, but I think it erodes the meaning of abstraction). LLMs behave like program synthesizers rather than another layer of abstraction. They take natural language as input, and using fancy math produce a (hopefully) relevant and useful output based on that input. They can produce layers of abstraction, but are not part of a program's abstraction stack. However, they can abstract away the need to understand implementation, similar to a coworker. They can summarize behavior, be queried for questions, etc, so you don't have to actually understand the inner workings of what is going on. This is a different form of abstraction than the typical abstraction stack of a program.
- larsfaye 6mo agoThis is exactly how I feel. I've begun referring to them as a "Delegation Layer", which is a new addition to the stack.
- resonancel 6mo agoI always think the determinism discourse on LLMs is off the point. The elephant in the room is semantic preservation. Compilers can most often preserve semantics across abstractions, while LLMs most often cannot. For sure the problem isn't that clear-cut, for the siren's call of AI coding is to induce a system out of prompts with ambiguous semantics. It's hardly surprisingly you get unpredictable outcomes when giving ambiguous commands to human collaborators, and that in the case of LLMs they resolve ambiguity with probabilistic approximation.
- yuye 6mo agoI thought the whole idea is that we have programming languages because turning a rigidly defined language (like C) into another rigidly defined language (like machine code) is relatively simple. Turning an ambiguous language with no formal definitions(like English) into one that does is a very hard problem.
- archagon 6mo ago"AI is an abstraction" only makes sense if working with a contractor to write your app is also an abstraction. An absurd dilution of the word "abstraction" to the point of meaninglessness.
- Mikhail_Edoshin 6mo agoThere was an article on database UX and it compared the expectations of a database user and a user working with a search engine. It's interesting, because both are searching, right? Yet the database user expects the found set to be complete or it expects an explanation on why this record is in it and this one is not. A search engine user does not expect things like that and will put up with false positives and negatives if their number is not too big.
- Havoc 6mo agoWhen people say things like that they mean it as a rough mental model. Bit like when people say "it's like riding a bike" they're not actually talking about bicyle riding being the exact same activity. Coming with this in response: > f(x) -> P(y) ∪ P(z1) ∪ P(z2) ∪ ... P(zN) is a failure in human communication not a disagreement about what LLMs are or aren't.
- deleted 6mo ago[deleted]
- TremendousJudge 6mo agoI'll believe that LLMs are like compilers the day a repo contains only the prompts and no generated code.
- sn9 6mo agoEveryone should Jimmy Koppel's post on what abstractions are and aren't: https://www.pathsensitive.com/2022/03/abstraction-not-what-you-think-it-is.html https://www.pathsensitive.com/2022/03/abstraction-not-what-y... Anyone claiming LLMs are an a higher level of abstraction are not using it in the way used by programmers and computer scientists. They're usually conflating "delegation" and "abstraction", as if a junior developer is an abstraction.
- srikanthsastry 6mo agoTechnically, the claim is true, but only technically. I think the reason it is not a reliable level of abstraction is due to what I like to call "directive gap" (https://srikanth.sastry.name/garden/directive-gap/ https://srikanth.sastry.name/garden/directive-gap/), which is the distance between the human's goal the context available to the LLM. Theoretically, if the directive gap is zero, then with very high probability you will get the correct code. If you think of 'programming in X' as a process, then you have multiple iterations as you go from incorrect code to correct code, and the same can be true of 'programming in LLM'. As you iterate on the prompts and have verification in place, whether it is spec verification, TLA+, unit testing, CI, etc., you can get the same effect. Now, it is an open question whether this is simpler than programming in any modern programming language. By the time you figure out the exact prompt trajectory that will build what you want, you might as well have used some fancy autocomplete IDE to write the same code. It really depends on your fluency with that specific language. People are usually very fluent in natural language, and so it levels the playing field so to speak.
- amdivia 6mo agoI mean, "Give me a Todo app" Is also different from "Write a function that takes a string parameter (Todo) and saves it into a text file with the name <current date time (as a Unix epoch)>.txt, and if already present, append to it to the file instead" The probability distribution for the potential output is different, and it's more limited in the second case perhaps. Besides, even the "deterministic" systems the author is referring to, are not fully deterministic. They are "deterministic" if we ignore a certain threshold of randomness that could afflict the system. Yes perhaps this threshold is higher when using LLMs, but even when using LLMs, not all inputs share the same level of indeterministic output
- Terr_ 6mo agoI think a less-brittle claim would be that they are at best a extraordinarily leaky and idiosyncratic layer of "abstraction" enough that for certain tasks you wouldn't want to actually use the term. It's like saying human personal assistant Bob is an abstraction over your calendar and shopping list. In other words, it depends where the people talking have placed their cutoff point for a good abstraction versus a terrible and unwise one.