Earlier this year I wrote that building got cheap and deciding didn’t. This is the sequel, and I can hand you the whole thesis in two sentences. The first 80 percent of building collapsed in price. The last 20 percent costs what it cost in 2019, and it’s quietly become most of the invoice.
I should be specific about what the last 20 percent is, because people hear “the last 20” and picture polish. Fonts, easing curves, the nice hover state. No. The last 20 percent is the empty state. The error state. The slow connection. The expired card. The user who does step four before step two. The integration whose documentation says one thing while the API does another (you find out which one’s lying in production, never before). The edge case that never appears in testing, because testing uses clean data and real data is never clean.
None of that is polish. That’s the part where the thing you built meets the world, and the world starts improvising.
A demo is an 80 percent artifact
Here’s a test you can run on any demo, including mine: ask what happens when the network drops mid-save. Every impressive demo you’ve ever seen runs on the happy path. Clean data, fast connection, a presenter who knows exactly which buttons to press in exactly which order. That’s not cheating. That’s what a demo is FOR. But it does mean a demo is built entirely out of the cheap 80 percent… and a product is built mostly out of the expensive 20.
If you’ve ever wondered why the app that wowed the room in April still isn’t in customers’ hands by September, this is usually why. Nothing went wrong. The demo was real. It’s just that “works when I drive it” and “holds when strangers drive it” are two different objects that happen to share a screenshot.
This was always true
Software people have a joke about this that’s old enough to rent a car. The ninety-ninety rule, coined by Tom Cargill at Bell Labs in the eighties: the first 90 percent of the code accounts for the first 90 percent of the development time, and the remaining 10 percent accounts for the other 90 percent. The math is wrong on purpose. Everyone who’s shipped anything laughs the tired laugh.
So no, AI didn’t create the last 20 percent. What it did was compress the FIRST 80 so hard that the proportions turned absurd. The scaffold, the layout, the working form, the parts that look like the product: an afternoon now. I’ve written about that collapse and I’m still glad about it. But the compression stops at the boundary, because the last 20 was never really typing. It’s finding out. You don’t learn that the integration’s docs lie until you’re holding a response that doesn’t match them. And no model can tell you what should happen when the card on file expires mid-checkout, because “should” isn’t in the codebase. Someone has to notice the question exists and then decide (no one mentioned a button is about that noticing).
And you can’t really schedule this part, which is what makes clients nervous and always has. The first 80 percent estimates cleanly because it’s known work. If you’ve built forty forms, you know what a form costs. The last 20 estimates badly because it isn’t work yet, it’s discovery. Nobody knows the docs lie until the response comes back wrong. Nobody knows which edge case real data is hiding, because that’s what “edge case” means. So the honest answer to “how long for the rest” has always been a range wide enough to feel like a shrug, and no amount of generated scaffolding tightens it.
There’s a stat that made the rounds last year… an MIT report found 95 percent of enterprise AI pilots stalling before they produced measurable results. A lot of ink got spilled on why. From where I sit it reads pretty simple: the pilots reached “it works.” They stalled in the 20, which is where “it holds” lives, and nobody had budgeted for that stretch of the work.
I’ll be honest about my own weeks here. I ship real work constantly, and most of my shipping time looks nothing like design. It’s what happens when the form gets submitted twice. It’s the email that bounces, the webhook that arrives out of order, the name that’s longer than the layout believed in. Unglamorous is the polite word for it. It’s also the actual job, and I’ve stopped being embarrassed by that.
Where the fee went
Now connect this to what clients can do themselves, because the floor rose and it’s still rising. A client with a prompt can reach “it works” without you. Genuinely. The demo they show you is real, and if your instinct is to feel threatened by it, I’d redirect the instinct: what they’ve built is the 80 percent, and the 80 percent was never the part they were paying for. They just couldn’t see that before, because the 80 used to be expensive enough to hide the 20 behind it.
That camouflage is gone. The gap between “it works” and “it holds” didn’t shrink when building got cheap. It got wider and easier to fall into, because more people arrive at the edge of it holding something that runs. Which means the professional fee has moved. “Done” lives in the last 20 percent, and so does the invoice.
The awkward part, and you should say this to clients out loud, is that the last 20 percent is invisible when it’s done well. Nobody screenshots the error state that didn’t confuse anyone. Nobody celebrates the double-charge that never happened. The happy path gets the applause. The other twelve states get you paid, and the only evidence they exist is that nothing ever goes wrong.
So when the demo lands on your desk already working, don’t compete with it. Finish it. Walk the states it doesn’t have, name the decisions nobody’s made yet, and price the stretch between “works” and “holds” honestly, because that stretch didn’t get smaller. If anything it’s busier than it’s ever been.
The first 80 percent got cheap and it isn’t coming back, which is good news all around. The last 20 costs what it always cost, because it was never building. It’s deciding, noticing, finding out.
The last 20 percent didn’t get cheaper. It just stopped hiding.