There is an old industry cartoon where a development manager stands before a room of engineers and says: “I’ll go up and find out what they need. The rest of you, start coding.” For decades, that was a good punchline. It represented the height of mismanagement and the guarantee of a failed project. But as agentic development takes hold, the joke has died. Starting the code before you really know the requirement is no longer a disaster: it is the most efficient way to get to the truth.
If the machine can build a functional prototype in the time it takes you to write a summary, why are we still pretending that the build is the bottleneck?
The traditional Agile loop was partly a defensive reaction to the high cost of human labour. We worked in sprints because two weeks of development was a justifiable price for uncovering the next layer of truth, whereas a twelve-month investment in a misunderstanding was a catastrophe. Today, that economic penalty has largely evaporated. The cost of a build is no longer measured in weeks of engineering time: it is a minute fraction of your compute budget. When the price of execution falls off a cliff, the value of the sprint as a risk-mitigation tool begins to look very different.
Agile hasn’t been debunked: it has been unmasked. We were always iterating to find the truth, but the high cost of manual coding acted like a filter. It forced us to slow down, often tricking us into believing the “build” was the objective. It never was. The objective has always been the discovery that happens when a stakeholder actually uses the solution. Now that the code is cheap, that distraction is gone. We can finally stop obsessing over the mechanics of delivery and focus on the feedback.
This doesn’t mean we have abandoned quality or architectural integrity. In many ways, we are simply scaling the Senior Architect. For years, our systems were built by juniors working under the guidance of seniors and the safety of automated guardrails. That structure hasn’t changed: the “junior” has simply become an agent that never sleeps and follows the architect’s patterns to the letter. The seniors are still there to mind the shop, but their leverage has increased ten-fold.
Think of it as a total collapse in the time to truth. We still need working software to tell us if our initial understanding was sound, but because the cost of reaching that build has plummeted, we are forced to recognise what we’ve been doing all along. We are “Agile” at the requirements layer. The planning and the post-mortems remain the guardrails, but the labour of the build is now a rounding error.
This discovery isn’t limited to end-user features. Our “customers” include the cyber security lead, the platform team, the engineers keeping the legacy monolith moving, etc, etc. The intent we orchestrate must include their requirements: security, scalability, and resilience.
This requires a shift in how we lead. We have spent twenty years obsessing over the “how” because it was the primary source of friction, but we can no longer ignore that the “what” was always the only thing that created value. The bottleneck is no longer the “doing.” It is the discovery.
We aren’t managing developers anymore. We are orchestrating intent.
The reality is that we are no longer running a development cycle: we are running a continuous, high-speed discovery session. The machine hasn’t changed the goal; it has just removed the tax we used to pay to reach it.
Leave a Reply
You must be logged in to post a comment.