LLMs Are Not a Higher Level of Abstraction

https://www.lelanthran.com/chap15/content.html

by lelanthran • 3 months ago

166 156 3 months ago

lelanthran.com

jqpabc1233• 3 months ago

In other words, LLMs are probabilistic, not deterministic.

sscaryterry• 3 months ago

Dare I say, so are humans?

jqpabc1233• 3 months ago

This used to be a big reason why we used computers --- to help eliminate the probability of error.

But apparently, not so much any more.

suttontom• 3 months ago

At this point this argument has crossed over into whataboutism.

kibwen3• 3 months ago

Determinism 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• 3 months ago

This 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• 3 months ago

You'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.

archagon2• 3 months ago

Then they should not pretend that they're still "engineers" working on a higher level of "abstraction".

conorbergin2• 3 months ago

LLMs 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• 3 months ago

You'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• 3 months ago

Yes theres a good thinking machines lab blog about this

2ndorderthought5• 3 months ago

That'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.

maplethorpe4• 3 months ago

Can 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?

slashdave• 3 months ago

Eh, conceptually true, but in practice, it is rather hard to get any decent performance out of a GPU and still produce a deterministic answer.

And in any case, setting the temperature to zero will not produce a useful result, unless you don't mind your LLM constantly running into infinite loops.

nnevatie2• 3 months ago

Namely setting temperature to zero, and turning off all history

That's not nearly enough, though. The multi-node/GPU inference and specifically batching (and ordering in batching) have non-deterministic consequences for the current LLM services.

mrob• 3 months ago

Whenever somebody calls LLMs "non-deterministic", assume they meant "chaotic", in the informal sense of being a system where small changes of input can cause large changes to output, and the only way to find out if it will happen is by running the full calculation.

For many applications, this is equally troublesome as true non-determinism.

conorbergin2• 3 months ago

I don't think LLMs are that chaotic, you can replace words in an input at get a similar answer, and they are very good at dealing with typos.

They are definitely not interpretable, I was reading some stuff from mechanistic interpretability researchers saying they've given up trying to build a bottom up model of how they work.

legerdemain• 3 months ago

This 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

maplethorpe4• 3 months ago

Abstraction has a specific meaning in computer programming. I don't think he's misrepresenting it.

https://en.wikipedia.org/wiki/Abstraction_(computer_science)

LeCompteSftware• 3 months ago

OP 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.

dimtion• 3 months ago

I'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.

distalx2• 3 months ago

A 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.

yunwal3• 3 months 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.

td2• 3 months ago

I mean if your talking about packets, your already one abstraction over the real data Transmission, in wich is noisy. So bits can randomly flip, noise could be interpreted as bits, and bits could get lost. A much larger blast radius

harrall• 3 months ago

A transmission error does not have a strictly contained blast radius.

A bad packet could tell a flying probe to fire all thrusters on and deplete its fuel in 15 minutes.

What makes a transmission error controlled is all the protection mechanisms on top of it. An LLM cannot delete a production database unless you give it access to do it.

My hot take is that many people are naturally more comfortable with deterministic systems that have clearly analyzable outcomes. Software engineering has historically primarily been oriented around deterministic systems and it has attracted that type of thinker.

But many of us, myself included, prefer chaotic systems where you can’t fully nail down every cause and effect. The challenge of building a prediction model on top of chaos is exhilarating. I really don’t find many people like me in SWE as in, say, the graphics design department.

To me, that’s the underlying threat here — LLMs are rewriting a field that has previously self selected a certain type of person and this, quite understandably, rubs them the wrong way.

DiscourseFan• 3 months ago

Very few people are even beginning to understand the constraints of these systems, and none of them have yet been elevated to high enough positions of prominence to rise above the noise of all the hype. Give us some time man, jeez

evrydayhustling2• 3 months ago

Besides deeply unpredictable factors (like signal transmission), most users of higher-level abstractions do so without certainty about how the translation will be executed. For example, one of the main selling points of C when I was growing up was that you could write code independent of architecture, and leave the architecture-specific translation to assembly to the compiler!

Abstractions often embrace nondeterministic translation because lower level details are unknown at time of expression -- which is the moivation for many LLM queries.

dominotw• 3 months ago

that would make sense if ai said "fail. i dont know" . Its active deception is what makes it difficult.

zadikian4• 3 months ago

I'm fine with that. The part that makes it not really an abstraction is, you still deliver code in the end. It'd be different if your deliverable were prompt+conversation, and the code were merely an intermediate build artifact. Usually people throw away the convo. Some have tried making markdown files the deliverable instead, so far that doesn't really work.

It makes even less sense when people compare an LLM to a compiler. Imagine making a pull request that's just adding a binary because you threw the source code away.

mpyne5• 3 months ago

The whole field of reproducible builds is only a field because compilers also have had trouble historically of producing binary artifacts with guaranteed provenance and binary compatibility even when built from the same source codes.

If I assign a bug fix ticket to a human developer on my team, I won't be able to precisely replicate how they go about solving the bug but for many bugs I can at least be assured that the bug will get solved, and that I understand the basic approach the assigned dev would use to troubleshoot and resolve the ticket.

This is an organizational abstraction but it's an abstraction just the same, leaky as it is.

danenania• 3 months ago

This is a great point. We’re very much in a transitional phase on this, but I personally do see signs in my own work with agents that we are heading toward the main deliverable being a readme/docs.

The code is still important, but I could see it becoming something that humans rarely engage with.

yomismoaqui• 3 months ago

The kicker is when you delegate some work to another team member and discover that humans are also non-deterministic.

bluefirebrand• 3 months ago

We can mitigate a lot of the problems with humans being non-deterministic by establishing trust and consequences

There are no consequences for a bad output from an LLM and idk about you but I don't trust them

qazxcvbnmlp• 3 months ago

Grocery stores are a level of abstraction. Exchange money, get food. If your whole life you had grown food, it might feel a bit strange.

Occasionally the low level details leak through ie: this egg came from this farm, theres a shipping issue so onions are more expensive or whatever.

I think llm assisted coding is going to work something like this.

vrighter8• 3 months ago

but you either exchange money and get the food you want, always. Or it's out of stock, so you don't get the food but you keep your money, guaranteed.

It's not a good analogy. With an LLM you might ask for a pea, be parted with your money, and be given a watermelon.

avazhi• 3 months ago

There’s a big difference between a packet being dropped and a packet’s meaning being changed along the way. The latter is better analogised to what LLMs do between receiving inputs and outputs.

jauntywundrkind• 3 months ago

People are really really weird about the non-determinism thing. Got someone very adamant that Prompt API shouldn't be a web standard because the output isn't deterministic and according to them that means we can't allow prompts.

Such strong correlation between narrow specific demands on how things have to be & posting, in general. I'd really like to see open mindedness & exploratory views be more frequent and have better standing, in general.

I do tend to think this is different than a level of abstraction. But it feels like it's trying to hit hard, on a pretty weird narrow point.

faangguyindia• 3 months ago

Machine itself is built on top of non deterministic world.

While your code is executing asteroid from space may hit it and halt execution.

cwyers• 3 months ago

If people can figure out how to write RFCs about IP over carrier pigeons for April Fools, they can figure out how to conceive of LLMs as a layer of abstraction beneath a protocol as well.

vrighter8• 3 months ago

You need to be able to define exactly what it's abstracting.

ex: std::shared_ptr is abstracting over raw pointers, and does refcounting. It is abstracting something but you can actually know exactly what that thing is. An LLM is an abstraction over the space of all possible computer programs. If an abstraction doesn't constrain you in some way, it's not an abstraction.

rock_artist• 3 months ago

I'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.

It depends on what's the abstraction.

Using LLM for coding is 'abstracting' the developer, adding extra layer that can produce code. But it's not abstraction layer of the code itself.

ritcgab• 3 months ago

Is "Mostly-reliable" TCP connection a real thing? A TCP connection is either reliable or not working at all. That is what a proper abstraction should be like.

kazinator• 3 months ago

This is about the reverse: a non-deterministic/stochastic system built using reliable abstractions.

Also, the problem of "did we receive the, and is it correct" is vastly trivial compared to "did we get correct LLM output".

The problem in networking is making the reliable transfer perform well under many conditions, and scale.

Getting consistently reliable output of LLMs isn't solved, so we can't talk about it scaling to even one instance.

HarHarVeryFunny7• 3 months ago

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.

That's more anthropomorphism than an abstraction. An LLM talks like a person because it was trained to predict continuations of human speech. That does not make it a person, or a system with intent, responsibility or any other human attribute. They are what they are: text prediction engines.

Perhaps your input to the LLM is "make all the test cases pass", and so it predicts it better do something to make the test cases pass, and does so by deleting the test cases. I guess in the "abstract" sense it did what you asked.

Or, how about the case in the news from a few days ago where an agentic system deleted all the vendor's customer's data, and last 3 months of backups, despite having been EXPLICITLY "told" not to do any such thing. Should we consider "completely fuck the customer" as an "abstraction" of "never delete any data"?

yongjik• 3 months ago

It'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• 3 months ago

it is a fruitless endeavour to try to appeal to a crowd that does not and will never understand the fundamentals of how llms work.

ofjcihen2• 3 months ago

I think that crowd would agree with you.

xpct• 3 months ago

Interesting. I believe some circles reached the consensus that they aren't creative, but that it's independent of their intelligence/modelling capabilities.

xigoi• 3 months ago

It’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• 3 months ago

LLMs 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.

danpalmer2• 3 months ago

Non-determinism is configurable at the level of the mathematical model, but current production systems do not support deterministic evaluation of LLMs.

orbital-decay3• 3 months ago

They 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".

calf• 3 months ago

There 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• 3 months ago

I 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.

farmdawgnation2• 3 months ago

I 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• 3 months ago

I 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"`.

hirako20002• 3 months ago

They are deterministic. Including in the way they fail.

vrighter8• 3 months ago

if a compiler bug is found, it can be fixed. You can't fix an llm.

farmdawgnation2• 3 months ago

One of these days I'm going to learn the lesson that my tongue in cheek doesn't always come across on HN.

royal__• 3 months ago

I 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• 3 months ago

I 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.

DauntingPear72• 3 months ago

theyre like an advanced form of program synthesis. Something that operates outside of the abstraction layering.

dakial1• 3 months ago

Your 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.

ofjcihen2• 3 months ago

Tangential 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• 3 months ago

The 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.

hirako20002• 3 months ago

The 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• 3 months ago

I 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• 3 months ago

This 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.

dpark10• 3 months 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.

slopinthebag2• 3 months ago

Can you explain how Python or C programs change from invocation to invocation?

dpark10• 3 months ago

Mostly 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.

HarHarVeryFunny7• 3 months ago

That's not a good analogy.

With a high level language implementation of any sort, the actual instructions executed by the CPU may vary according to how it was compiled or run, or what machine you run it on, but the behavior will not.

The high level language defines it's own level of abstraction, defining exact behavior, allowing the developer to have full control over program behavior, algorithms, UI, etc.

An LLM + natural language instructions is not a program-like abstraction of what you want the computer to do, because it does not have that level of precision. Natural languages are fuzzy and imprecise, because they have been developed for communication, not precise machine-level specification.

Obviously you can "vibe code" at different levels of detail, ranging from "build me an app to do X" to "here are 20 1000 word essays specifying the dos and don'ts of what I want you to build", but in either case you are nowhere near the level of precision of using a programming language to specify exactly what you want.

So sure, "vibe coding" let's you accomplish A result with less attention to detail than using a programming language, but it's not a "higher level abstraction" in the sense that HLLs are, since it doesn't define what that abstraction is. It lets you get A result, but not define a SPECIFIC result, since natural languages just aren't that precise... natural language means whatever the person/thing interpreting it interprets it to mean.

Of course you can use an LLM as a way to "rough out" a function or app, and as a crude tool to manipulate that roughed out form (or an existing project), but natural language does not have precise semantics and therefore cannot provide a precise definition of what you want to do.

dpark10• 3 months ago

It wasn’t my analogy. It was the article’s so I responded to that. There are many more (and better) examples of how abstractions give up control, precision, and/or determinism.

The high level language defines it's own level of abstraction, defining exact behavior

This is not entirely true. A high level language defines some behaviors, leaving many behaviors to be undefined and implementation specific.

Many of those unspecified behaviors can matter in some cases.

It lets you get A result, but not define a SPECIFIC result, since natural languages just aren't that precise...

You are repeating the same error as the article and missing the fact that while an abstraction lets you specify or control some things, it leaves many things out of your control. The higher the abstraction, the more stuff that is left out of your control. And maybe you don’t care about the things outside your control (great, the abstraction worked!) but regardless there are many things left unspecified in the typical abstraction and very often eventually you will care, which is why people say things like “all abstractions are leaky”.

For a simple example, think of writing something like this:

MessageBox(“hello world”, OkCancel)

MessageBox is an abstraction over a massive amount of logic. You specified a string and a set of buttons and not much else. You give up control over the styling, the placement of the buttons, the actual button text (very likely will be localized), where the box will appear, and so much more.

You are not getting a specific result. You are getting a result that meets the contract.

“Write a program that shows a hello world message box” is a much higher level of abstraction than even that, and you are giving up significant specificity and determinism. Is it a good abstraction? That’s a great question. But it certainly is an abstraction.

UltraSane• 3 months ago

The 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• 3 months ago

Really anything can (and must) be written to justify delegated thought. See: replies to this thread.

DauntingPear72• 3 months ago

I 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• 2 months ago

This is exactly how I feel. I've begun referring to them as a "Delegation Layer", which is a new addition to the stack.

resonancel• 3 months ago

I 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.

yuye3• 3 months ago

I 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.

archagon2• 3 months 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• 3 months ago

There 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• 3 months ago

When 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.

TremendousJudge• 3 months ago

I'll believe that LLMs are like compilers the day a repo contains only the prompts and no generated code.

sn9• 3 months ago

Everyone should Jimmy Koppel's post on what abstractions are and aren't: 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• 3 months ago

Technically, 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/), 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• 3 months ago

I 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_• 3 months ago

I 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.

LLMs Are Not a Higher Level of Abstraction

Related Stories