Article 5: The Case Against Code

Or: What Evolution Teaches Us About LLMs

Donald Hoffman has spent decades arguing that we don’t see reality.

Not because we’re broken. Because we’re optimised.

---

The Fitness Interface

Hoffman is a cognitive scientist at UC Irvine. His theory: evolution didn’t shape our perception to see truth. It shaped us to see what’s USEFUL.

We don’t see the world as it is. We see a desktop.

Think about your computer. You see icons. Folders. A trash can. None of these things “exist” inside the machine. There are no tiny folders in there. The icon is an interface — a useful fiction that lets you get things done without understanding voltages and transistors.

Hoffman argues that reality is like this. The apple you see isn’t the apple as it is. It’s an icon. A symbol your brain renders because it’s useful for survival.

Organisms that evolved to see “truth” got outcompeted by organisms that evolved to see “fitness.”

The interface won.

---

The Case Against Code

I think there’s a version of this for software.

Developers are trained to believe they should understand their code. See the reality underneath. Maintain it. Own it. Know every line.

But what if that’s like trying to see past the desktop icons?

What if the most effective developers aren’t the ones who see “truth” — but the ones who work skillfully at the interface level?

---

Specs as Icons

When you write a spec and let an LLM generate code, you’re working at the interface level.

You’re not manipulating transistors. You’re not even manipulating code, really. You’re manipulating meaning. Intent. Outcome.

The spec is your icon. The generated code is the voltage underneath — real, but not where you live.

And just like Hoffman’s fitness interface: you don’t need to see underneath to get things done. In fact, trying to see underneath might slow you down.

---

Fitness Beats Truth

Hoffman ran evolutionary simulations. He pitted “truth-seeing” organisms against “fitness-seeing” organisms.

Fitness won. Every time.

The organisms that saw reality accurately went extinct. The ones that saw useful fictions — the ones tuned for action, not accuracy — survived.

I think something similar is happening in software.

Developers who try to maintain every line of code, who try to “see the truth” of their entire codebase, are being outcompeted.

By who?

By developers who maintain specs. Who regenerate instead of debug. Who work at the interface level and let the LLM handle the voltage underneath.

Fitness beats truth. Interfaces beat internals. Specs beat code.

---

The Desktop is Real Enough

Here’s the thing about Hoffman’s theory: he’s not saying the desktop is fake. He’s saying it’s USEFUL.

The trash can works. You can delete files with it. The fact that there’s no tiny bin inside your computer doesn’t make the icon useless — it makes it an effective interface.

Same with specs.

Your spec isn’t the “real” code. But it works. You can build software with it. The fact that you didn’t write every line doesn’t make the output useless — it makes the spec an effective interface.

The desktop is real enough. The spec is real enough.

---

What You Maintain

Hoffman’s interface theory asks: what level should you operate at?

Not the deepest level. Not the “truest” level. The level that’s tuned for fitness. For getting things done. For surviving.

For developers, this means asking: what do I actually maintain?

Not every line of generated code. Not the “truth” of your codebase.

You maintain:

• The specs (your icons)

• The durable foundations (databases, auth, core logic)

• Your ability to regenerate (the LLM-as-compiler workflow)

Everything else is voltage. Let it flow.

---

The Case for Interfaces

Hoffman’s work is controversial. Some call it radical. Some call it obvious dressed up in math.

But the core insight feels true to me:

We’re not built to see reality. We’re built to work with it.

And maybe that’s what mcauldronism is really about. Not pretending we can see every line of code. Not maintaining the unmaintainable. But building good interfaces — specs, tools, workflows — and trusting them to handle the depth.

The case against reality is the case for interfaces.

The case against code is the case for specs.

Work at the level that works.

---

[Part 1: Where Do You End?] [Part 2: The Maintenance Cost is Zero] [Part 3: The Cauldron in the Spectrogram]