What Happens After Coding Is Solved?

Ask a builder what slows them down and the honest answer used to be: writing the code. Not deciding what to write — the typing. The plumbing. The third attempt at the same function. That was the tax on every idea, and we all just paid it.

That tax is collapsing. Which makes the interesting question not "will coding get solved," but the one Boris Cherny keeps poking at: what becomes scarce when it does?

The constraint always moves. That's the whole game.

There's a law hiding under this, and it's older than software. Eli Goldratt built a entire management philosophy on it in The Goal: every system has exactly one binding constraint, and the moment you relieve it, a new one appears somewhere upstream. You don't finish. You relocate the bottleneck.

We've watched this happen in our own field over and over. Compilers got good, and nobody mourned hand-writing assembly — the constraint moved up to design and architecture. Frameworks got good, and nobody missed wiring up boilerplate — the constraint moved up to product decisions. Each layer of "solved" didn't end the work. It pushed it somewhere harder to automate.

Coding getting solved is the same move, one floor higher. The plumbing stops mattering. What's left is everything the plumbing was distracting you from.

There's a paradox waiting on the other side

Make something cheaper and people assume you'll need less of it. Usually the opposite happens.

In 1865 the economist William Jevons noticed that more efficient steam engines didn't reduce coal use — they increased it, because cheap power made coal worth burning for a hundred new things. Cheap code works the same way. We won't write less software. We'll write wildly more of it, including a great deal of software that should never have existed, because the cost that used to stop us is gone.

That's the real shift. Not less work. More output, and a desperate new need for judgment about which of it is worth having.

What actually gets scarce

Three things, in rough order of how badly they're undervalued right now.

Knowing what to build. When building was expensive, a mediocre idea was protected by the cost of executing it — you'd never blow three weeks on something obviously weak. Now you can build the weak thing before lunch, which means you'll build a lot of weak things unless your judgment about which thing is sharp. Problem selection used to be cushioned by scarcity. The cushion is gone.

Taste. When everyone can generate a working version, "working" stops being a differentiator. The gap between a competent output and a great one is taste — and taste is exactly what the model supplies least. It'll hand you the median solution to your prompt, every time. Knowing the median isn't good enough, and knowing what better looks like, is on you.

Verification. This is the sleeper, and the one I'd bet on. If an agent emits a thousand lines a minute, your ability to confirm those lines are correct becomes the actual rate limit. The bottleneck quietly shifts from "can I make it" to "can I trust what got made." Teams that can't verify quickly will drown in plausible output nobody is willing to sign their name to.

What a good day starts to look like

The old loop was write, compile, debug, repeat, measured in minutes. The new loop is request, output, verify, repeat, measured in seconds. The center of gravity moved from production to specification and judgment.

That changes the texture of the work. Less time in the editor. More time deciding what's worth doing, framing it precisely enough that an agent won't wander off, and checking the result against a bar you hold in your head. It feels less like construction and more like directing.

It also rewards a different temperament. When the cost of trying something drops to near zero, the person who just tries things beats the person who plans them. Agency starts beating skill — because skill is increasingly something you can summon on demand, and agency is something you either bring or you don't.

---

So what do you actually do about it

Stop investing in being a faster typist. That market is closing, and it isn't reopening.

Invest in the three scarce things instead. Get a little obsessive about which problems are worth solving. Build taste by studying work better than yours until you can feel the difference, not just describe it. And develop a verification habit so strong you can take a wall of agent output and know, fast, whether to trust it.

Coding getting solved isn't the end of the work. It's the part where the work finally gets to be about judgment. Which is a better job — if you're ready for it.