Liberty Workbench is an occasional series where I put one idea on the bench and think it through with you.

Byrne Hobart (friend-of-the-show and long-time supporter 💚 🥃) wrote Convergent Evolution in the Architecture of Intelligence, and it sparked many thoughts.

The line from Byrne that got me thinking:

Effectively deploying a fixed amount of intelligence means having a relentless focus on maximizing the amount of stupidity you can get away with.

He uses a coffee-pouring robot as an example. You need a sophisticated AI model to understand the high-level instruction (pour me a cup of coffee) and figure out what needs to happen. But you don’t want that expensive model micromanaging every tiny adjustment of the robot’s arm. ☕🦾

Instead, the intelligent system decomposes the complicated job into simpler and simpler tasks until a lot of the actual execution can be handled by dumb control loops and ‘if/then’ rules running on cheap hardware.

The smart part figures out where it can get away with being stupid.

Those Jacquard cards at the top are an old version of that: encode the pattern once, then let the loom repeat it mechanically.

That connected with something I’ve been thinking about lately: better intelligence making existing assets more useful.

In that piece, the idea was that better intelligence can make old capital more useful. The other side is that some inference leaves productive assets behind: spend the expensive, flexible intelligence once figuring out what’s going on, and whatever it discovers can be reused thousands or millions of times.

A flow of cognition becomes a stock of capital. 🧠 → 🏭

The Best Use of Intelligence Is Making Itself Unnecessary

You start with something expensive and flexible, a big, complex frontier model reasoning through a problem, trying things, making mistakes, figuring out what matters. 🤔💭

But next time, maybe you don’t need the big model to reason through the whole thing again. You can bottle some of what it figured out in something much cheaper. 🫙

Maybe it writes some code or builds a little tool. Maybe it figures out a rule or teaches a smaller model. Whatever. 💾 🛠️🧰

frontier reasoning → discovered structure → code/rules/smaller model → cheap repetition

That’s kind of what humans have always done. The math wizard thinks hard about something for years and comes up with a formula. The engineer makes countless attempts and figures out what works by trial and error.

A few steps later, millions of people can benefit from that thinking without giving it much thought, or even understanding it: click around in software, use a machine, whatever. How many hours of deep thinking are embedded in, say, an iPhone? 📲

AI doesn’t change the underlying pattern, but it should accelerate it A LOT. The same system doing the thinking can also write the code, help train the new specialist model, or help design the machine that captures what it learned.

There’s already a pretty literal example of this happening. Google DeepMind’s AlphaEvolve found a simplification in a highly optimized matrix-multiplication circuit for an upcoming TPU. Jeff Dean described one of its circuit designs as “so counterintuitive yet efficient that it was integrated directly into the silicon of our next-generation TPUs.”

That’s intelligence being compiled into machinery about as literally as you can get. 🧠 → 💾 → ⚙️

And you skip a lot of the human handoffs and back-and-forth that slow big organizations down.

I recently wrote that software used to amplify labor, while AI is making software itself into a kind of labor. Give an AI agent access to tools and the web, and it can do an increasing amount of white-collar work.

Then the loop can close:

software → labor → software 🔄

The AI does a job, figures out which parts actually require judgment, and writes software for the rest. The Smart Thing makes a Dumb Thing that replaces it. At least for that particular job.

In the words of Alfred North Whitehead: Civilization advances by extending the number of important operations which we can perform without thinking of them.

So far, that machinery is mostly digital, but eventually more of it will be physical too.

You might spend a bunch of expensive frontier tokens to figure out some annoying task and build a 200-line utility.

The utility might run thousands of times on an old CPU and cost basically nothing by comparison.

Obviously, this only works if there’s some real structure there to find. But I suspect that the smarter a person or AI model is, the better they are at finding it, even in complex systems.

Not everything is equally easy to ‘compile.’ The best candidates give you a cheap way to know if what you built works. They also tend to repeat a lot, change slowly, and can be broken into smaller pieces.

AI is becoming a compiler for intelligence — Click for larger version.

Code is a great fit because it has tests. Robots have sensors that provide immediate feedback. Some repetitive business processes have outputs you can measure.

But fuzzy stuff like ‘make a great strategic decision’ is harder to turn into a dumb loop because you may not know for a long time if the decision was good (and even when it turns out well, it could have been luck or other factors…).

And this isn’t a fixed boundary. As reliable verification gets cheaper, more cognition becomes compilable.

There’s also a break-even point. The dumb solution isn’t free to build or maintain, and dumb solutions can be brittle. That’s partly why they’re cheap: they don’t stop and rethink everything when the world changes. But the danger is when they don’t fail in an obvious way and just keep doing what they’ve been doing even after the world has changed. 😬

So there are two forces pushing in opposite directions here. Smarter models should keep finding more things that can be compiled. But if inference gets cheap enough, sometimes why bother? Just let the smart thing think again. ↕️ 🤔

Back to Byrne’s coffee robot for a sec. Once the intelligent model has decomposed the job enough that simple control loops can handle most of the execution, the intelligence doesn’t just have to sit there idle. It can migrate upward.

If you don’t have to control every tiny movement, you can spend that intelligence on exceptions and weird edge cases instead. And eventually some of those may stop looking so weird. You find the pattern, compile that away too, and move up again. Rinse and repeat.

AI Can Cannibalize Its Own Future Inference

Once a task has been compiled away, the expensive intelligence can go looking for the next one. So you can need less and less intelligence for each thing you’ve already figured out, while using more and more intelligence overall. 📉📈

I used to picture sci-fi AI as super-smart and constantly thinking about everything, running everything. But maybe that’s backwards. A fantastically intelligent AI might spend a lot of its time figuring out where it can get away with stupid automations and save the compute for harder stuff.

Maybe a much more intelligent world ends up full of much stupider machinery, because intelligence has already been compiled into it. ⚙️

🔁 Déjà vu:

Edition 638 — software cycle times collapsing from months to hours, turning speed from quantitative to qualitative.
Edition 605 — intelligence as a universal input: when it gets cheaper, total consumption rises.
Edition 627 — intelligence migrating toward problems humans under-serve or prefer not to work on.
Edition 647 — cheap implementation turning prototyping and iteration into the new bottleneck.

Liberty Workbench is where I put one idea on the bench and think it through. Every Workbench edition is collected here.

AI Is Becoming a Compiler for Intelligence