Introduction
There was a time when building software was the work.
Methods like Use Case Points (UCP) gave us a structured way to estimate implementation effort—because implementation was the dominant cost.
That assumption is now broken. AI coding agents have collapsed implementation time by an order of magnitude. At the same time, approaches like Rupify turn specifications into executable, verifiable inputs that can steer those agents [1].
This sets up a new tension.
The Real Tension: Speed vs. Correctness
The Wiggum Loop shows that you can brute-force progress with AI through rapid iteration [2]. But it also shows where that breaks: when failures are silent, slow, or irreversible. That is exactly the regime most enterprise systems operate in. So this is the core tension:
The Wiggum Loop is powerful precisely where it is dangerous. Fast iteration in domains where incorrect systems are costly. This is where Rupify resolves this tension. It does not slow the loop down. It constrains it.
It makes fast iteration safe enough to use in high-stakes environments by making intent explicit and verifiable.
The Failure Mode: Faster Divergence
Without that constraint, AI does not give you better outcomes. It just gives you incorrect systems, delivered quickly.
Organizationally, this looks like:
- Systems that appear complete but encode the wrong logic
- Silent misalignment between business intent and system behavior
- Accelerated rework cycles where errors propagate faster than they are detected
The result is not efficiency. It is amplified waste. This is why specification becomes the control point.
The Inversion
This creates a structural inversion:
- UCP still estimates human implementation effort
- AI reduces actual implementation time to a fraction
- Rupify ensures the output remains aligned with intent
So the traditional model—where effort ≈ implementation ≈ value—no longer holds.
UCP Was Measuring the Wrong Thing
You can still calculate UCP. But it no longer answers the original question: How long will this take to build?
That question is now nearly irrelevant, what remains is something more fundamental: How complex is the problem space?
UCP was always approximating this. So AI did not make UCP obsolete, it revealed what UCP was actually measuring all along.
Knowing complexity is crucial for coding with AI Agents [5].
A New Model
We end up with a new structure:
- UCP measures problem complexity
- Rupify translates complexity into executable intent [1]
- AI agents handle implementation at near-zero marginal cost
What Consulting Becomes
This connects directly to outcome-based value models [4].
In this new model consulting is the discipline of reducing ambiguity. That is not a slogan. It is a structural shift.
It changes:
- Staffing → fewer implementers, more domain modelers and specification engineers
- Pricing → from time-based delivery to value of clarified and executable intent
- Differentiation → ability to make complex systems unambiguous, not ability to build them
The scarce role is the person who can:
- Extract intent from messy organizational reality
- Structure it into a precise model
- Express it in a form that machines can execute correctly
That capability becomes the bottleneck.
The Final Constraint: Can It Be Safely Realized?
Even perfect specifications are not sufficient.
They must be realized through a trustworthy system [3].
A correctly specified system built through a compromised pipeline is still a compromised system.
So the full model becomes:
- Clarity of intent (Rupify)
- Controllability of generation (AI agents)
- Trustworthiness of realization (supply chain)
Remove any one of these, and the system fails.
The Shift
Software engineering is no longer about building systems.
It is about:
- Describing them correctly
- Constraining how they are generated
- Ensuring they can be safely realized
Implementation has not disappeared, but it has lost its position as the center of value – and when that happens, everything around it has to be rethought.
Conclusion
Implementation is no longer the primary driver of cost, time, or value.
Value is created by reducing ambiguity, expressing intent precisely, and ensuring that intent can be safely realized.
- AI accelerates execution
- Rupify constrains it
- UCP reveals the true complexity underneath
Consulting shifts from delivering software to making systems unambiguous and executable.
References
[2] https://birkholm-buch.dk/2026/04/05/the-wiggum-loop-brute-forcing-business-with-ai/
[3] https://birkholm-buch.dk/2026/03/13/move-the-security-boundary-to-the-software-supply-chain/
[5] https://birkholm-buch.dk/2024/12/12/speed-vs-precision-in-ai-development/
