Building got cheap. Deciding didn’t.
AI collapsed the cost of writing code. The expensive part is now knowing what to build — and that part got quieter, not easier.
For most of software’s history, the expensive part was typing. Code took people, people took months, months took budgets, so every decision got argued carefully — you couldn’t afford to be wrong at $200 an hour of programming.
That constraint is gone. A working prototype now costs a weekend. And yet software projects still fail at roughly the same rate they always did, because they never failed at the typing. They failed at the deciding. The failure just moved upstream, where it’s quieter.
The wrong thing, built perfectly
An AI will build the wrong thing with total confidence and beautiful code. It doesn’t ask whether the description it was handed is right. It fills every gap with a plausible guess — the same database schema every tutorial uses, the same workflow every other business apparently has — and ships it.
So the risk isn’t that you can’t build fast anymore. The risk is that you can now build the wrong thing fast, discover it three months in, and have saved nothing. Money spent deciding is the only money that scales down the total bill.
What deciding well looks like
It’s less mystical than it sounds. It’s a week of focused work, and it produces writing, not software.
- What is it for, in one sentence — the thing that’s true when this is done. If two people in the room give two different sentences, you’ve found the expensive bug while it still costs nothing.
- Who uses it, doing exactly what — named people, named tasks, a bad day included.
- What it connects to — the systems, records, and reports this has to agree with. Most “technical surprises” late in a project were knowable facts in week one.
- What it deliberately doesn’t do — the version you’re building first, and the things you’re consciously leaving out. Scope you never chose is scope creep with a head start.
- What happens when it’s wrong — who notices, how fast, and who fixes it.
One page each. Plain language. Everyone who will touch the thing reads it and argues with it while it’s still cheap to argue.
The uncomfortable incentive
A builder paid by the hour benefits from your decisions being fuzzy. Rework is revenue. When you pay for deciding separately from building, the incentive flips — a good plan is the product, whether or not the builder gets the build.
A plan that fits on a few pages beats a prototype that hides a decision nobody made. Build the plan first. Then let the machines type.
Working on something this applies to? Tell us about it — thirty minutes, no pitch.