I hear two common refrains in discussions of LLMs:

• That they're "just the next level of abstraction, like machine code to assembly".
• That they're "just the next level of automation, like using a table saw or a backhoe".

Both of these statements are wrong to the level of being moronic, and as a result are functioning as thought-terminating cliches (opens new window).

To be clear, I'm not against LLMs on principal, and I think there are ways they can be useful. But the current dialog around them is exhausting and stupid, and I can't stand people making these two particular errors anymore.

To use an LLM is to delegate

To best understand why LLMs aren't like compilers or power tools, I want to make clear why delegation is always a better metaphor, and therefore why the other metaphors are so misleading.

When you delegate any amount of work to a person, you can't be sure exactly what you're going to get. A person is a stochastic entity (at least from your perspective), and like any stochastic entity, it can't be precisely controlled in any meaningful way. The Principal-Agent Problem (opens new window) is one of the most difficult and stubborn problems in society.

Humans have many bone-deep evolved intuitions for how to deal with humans, and one of the big ones is to just know you very well might be disappointed! ("If you want something done right, do it yourself.") Delegating work to others and actually getting something useful is extremely hard, despite the fact that humans have general intelligence.

LLMs are profoundly strange by contrast, because they're fundamentally dissimilar to humans, and yet their intrinsic design is to mimic a thing we've only ever experienced humans doing.

A metaphor I've found humorous (but which I'm guessing is disrespectful to addicts and their families... sorry) is that an LLM is like a meth-head who's read the entire internet:

• They're enthusiastic and work without tire or complaint.
• They often do work that is acceptable, but not without lots of back-and-forth.
• If left to their own devices they write wacky code (opens new window).
• They make bizarre and confounding mistakes (opens new window), like being unable to count words or letters (opens new window).
• And sometimes they delete the entire production database (opens new window), or expose all your user data or secrets to the internet (opens new window).

Let me be clear: there are situations where I would definitely find it useful (although certainly not ethical...) to delegate some knowledge task to 100 meth-heads (listen to these podcasts and find all the times they talk about type safety; read all US supreme court decisions to find the ones about open source software; third funny example). But I personally think those situations are rare and narrow.

For a time I was tempted to say using an LLM on a project is like outsourcing it to a contractor, but I only think the comparison has any juice if the contractor is pretty bad or has misaligned incentives, or there's a serious language barrier between the groups.

But fundamentally any metaphor will be inadequate, LLMs are too weird. It doesn't make sense to compare a transformer-based deep neural network that autoregressively generates language tokens based on their embedding in a high-dimensional semantic space (opens new window) to really anything that's ever existed.

Compilers and power tools are deterministic

Both compilers and power tools are intentionally designed to be completely predictable. The entire point of such tools is that they present a fair amount of automatic power behind the narrowest interface possible. They are machines designed to fully realize the promise of machines, in that they have no will or quirks, you don't have to say thank you (or bully them (opens new window)), and they do exactly the same thing all the time.

• Power tools package up a large amount of mechanical complexity behind the smallest number of controls possible, e.g. a power button, a control handle, a steering wheel. The intention is that a person can complete repetitive work much faster, work at a much higher level of quality, and hopefully do that work much more safely.
• Compilers and programming languages are intrinsically about deterministically reusing precise logical structures. All the decisions they made allow you to not have to make those decisions again. Writing reusable software is like you designed some machine part (like a pulley or a gear), but everyone can infinitely copy it and use it precisely the way you designed it.

The interface of an LLM is natural language, and natural language is the most unreliable/fuzzy/imprecise/unpredictable interface to a system possible.

Natural language is the interface of last resort. It's fully general, but it's also furiously ambiguous. Humans fall back to natural language when no other more precise way to describe what we want is available to us, either because it doesn't exist or we don't know it comfortably. We draw diagrams and blueprints and write math equations for a reason!

Backhoes have buttons and joysticks and levers etc because those interfaces make the operation of the machine precise. Computer languages and the GUIs we build with them are constructions of pure logic, meaning we can know exactly what they mean if we do the work to understand them. Natural language could certainly be a smooth onramp (opens new window) to many systems, but once someone knows a discrete interface well, it will always be faster for them to use it than say everything in natural language.

---

The entire point of using tools is to predictably solve a repetitive problem. LLMs by contrast reproduce a weirder and more confusing version of the principal-agent problem.

Whether you're down for that is up to you, just don't try to convince me you aren't actually delegating.