Last month I sat in a steering committee meeting. Eight people, two hours, to decide if a feature should be prioritized for the next sprint. Estimated salary cost for the meeting: 15,000 SEK.
The next day I built a working prototype of the same feature with AI. Time: three hours. Cost: essentially zero.
The meeting cost more than just building what we talked about.
This isn't an anecdote. It's a symptom of a structural problem. Our IT processes are designed for an economy that no longer exists.
The Old Logic
Traditional IT governance is built on a simple calculation: developer time is expensive, planning is cheap. Spend time specifying, prioritizing, and approving—to avoid wasting expensive execution time on the wrong things.
Requirements specifications. Sprint planning. Stakeholder meetings. Technical specifications. Backlogs where ideas queue for months to access the scarce development capacity.
All of this was rational when a small project cost hundreds of thousands in development. A steering committee meeting costing 200,000 SEK that prevents a bad decision worth twenty million is obviously well invested.
The Math Has Changed
Now the calculation looks different.
The steering committee meeting still costs 200,000 SEK. But the prototype that previously took a developer two weeks can be generated in an afternoon. The execution cost has gone from hundreds of thousands to a few thousand.
Suddenly the approval process costs more than actually testing the idea.
This turns the entire logic upside down. When execution is expensive, we optimize to avoid bad ideas. When execution is cheap, we should optimize to test ideas quickly.
Most organizations haven't adjusted. They're still running processes designed for a bottleneck that has moved.
Three Things That Change
1. Build Instead of Specify
When someone has an idea, the fastest path to evaluation is often a working prototype, not a requirements document. The prototype answers questions the document can only speculate about.
I've seen teams spend three weeks specifying a solution that took four hours to build with AI. The specification was also wrong on several points that only became obvious once the prototype existed.
2. Invert the Approval Flow
Traditional: approve the idea, then build.
Now: build proof-of-concept, then approve for production.
Let AI create the first version. Humans decide if it should be scaled. The approval meeting becomes shorter and better—we discuss something concrete instead of speculating about a document.
3. Measure Differently
Stop measuring how well you estimate projects. Start measuring how quickly you can test hypotheses.
"We were right in our estimate" is irrelevant if you could have tested the idea in a fraction of the time it took to estimate it.
The Cultural Problem
This isn't just a process change. It's a cultural shift.
Many organizations have built their identity around careful planning and comprehensive analysis. Teams are proud of thick decision documents and rigorous governance. Saying "just build and see" feels irresponsible.
But clinging to expensive planning processes when execution is cheap isn't responsible. It's waste. The discipline that once made organizations effective now makes them slow.
The hard part isn't understanding the logic. The hard part is accepting that what you're good at has become less valuable.
Actions
1. Start with low-risk experiments. Identify ideas with limited scope. Let teams build prototypes without the full approval flow. See what happens.
2. Calculate the delay cost. When an idea sits three months in the backlog—what does it cost? Compare with just building it and evaluating.
3. Create fast lanes. Establish flows for AI-assisted development that run alongside traditional processes when the cost is below a certain level.
4. Ask the question every time. Before you book a planning meeting: could we just build this instead?
Conclusion
The bottleneck has moved from execution to decisions. Our processes are optimized to protect developer time—but developer time is no longer the scarce resource.
The scarce resource is now the ability to quickly evaluate what works.
Organizations that understand this will test ten ideas while we're still specifying one. The question isn't whether our processes need to change. The question is how long we can afford to wait.