AI's Abstraction Problem
Technology advances through abstractions. An abstraction lets you work at a higher level without thinking about the level below. Nobody building a web app thinks about electrical signals. Nobody running a company thinks about how payroll moves money between banks. Someone tucked those problems away, and we all got to think one level up.
An abstraction trades control for leverage. You give up the details, and in exchange you move faster and think bigger. For most of us, most of the time, that's a great deal. It's how every generation of technology builds on the last.
Opaque is the point
The trade only works when the abstraction is airtight. The entire value rests on the ability to ignore the old layer.
When an abstraction leaks, you get the worst of both worlds. You still have to understand the lower level, because it keeps breaking through. Now you also have to understand the new layer, and figure out which one is failing you this time. You're paying twice.
A leaky abstraction only pretends we've created a new level of thought, a new layer of ease. In reality, our hands are still in the lower level, grubbing around. We just put a bow on it.
The most ambitious abstraction yet
AI is the biggest abstraction we've ever attempted. The pitch is a "junior employee": hand off the work the way you'd hand it to a person, and stop thinking about how it gets done.
That's an enormous promise, and today it leaks like a sieve. You can see it whenever you're checking every output, re-explaining context, or working around quirks. Each of those is your hands back in the lower level.
That doesn't mean the technology isn't powerful. Rather, it's a matter of scope and expectations. The more an abstraction promises to handle, the more places it can break, and "anything a person could do" covers a lot of ground.
An aside for the devs: I'm especially disappointed with code generation lately. Prompting for changes has made coding faster but didn't actually give us a new abstraction, only a new interface - and it's one that obfuscates and intermediates. As I look into building actual abstractions, I find hands-off generation is not keeping up.
Make it smaller
The way forward is to find specific arenas where you can actually hand off the job to AI and stop thinking about it.
An arena is ripe for an airtight abstraction when:
The inputs are well-defined. The AI gets what it needs in a known shape, not a different pile of context every time.
The output can be checked without a human expert. A test passes, a number reconciles, a format validates.
The failure modes are known. It breaks in ways you've seen before and can catch.
The boundary is explicit. Everyone knows what's inside the abstraction and what isn't.
The narrower the arena, the easier each of these gets. Every abstraction we rely on today got there the same way: none of them promised everything, and each one owned a single problem so completely that we forgot it was ever a problem.
This is why "vertical AI" tools are making a splash right now. They're taking a much smaller bite out of the world, attacking problems they have some hope of actually abstracting. There's still a lot of work required to solve those problems, but the smaller you start, the sooner it works.
This is also where taste comes into play. When you give up control for leverage, the leverage needs to move the needle for you. There are many ways to solve any problem, and reasonable people can disagree wildly on the ideal interface.
Finding good abstractions
The next time you're evaluating an AI tool, or your team is pitching an AI project, ask three questions:
What level does this let us work at? Name the abstraction.
What would we get to stop thinking about? If the answer is "nothing," it isn't an abstraction yet.
How small can we make it? A small abstraction that holds beats a big one that leaks.
The AI that wins won't be the one that promises to do everything. It'll be the one you can finally stop thinking about.
If you're interested in how this applies to software generation, check out Decision Engineering.