The SDLC in the Age of Agents: When Everything Happens at Once
Reducing the SDLC down to <5 mins with AI Agents
For decades, we’ve organised software development around the comforting fiction of sequential phases. Requirements feed into design, design feeds into implementation, implementation feeds into testing. Even when we adopted agile methods and claimed to embrace iteration, we still thought in terms of discrete phases happening in some kind of order, even if that order repeated itself every fortnight.
AI agents are dismantling this mental model, not by making the SDLC (Software Development Lifecycle) linear, but by making it simultaneously occurring. And that creates a fundamental tension with how most organisations actually govern technology delivery.
The Collapse of Sequential Thinking
The traditional SDLC assumed that each phase took long enough that you could staff it separately, review it separately, and approve it separately. Weeks or months gave us natural breakpoints. But when the time from “here’s a requirement” to “here’s working, tested code” collapses to hours, those breakpoints evaporate.
This isn’t about speed alone. It’s about the fundamental nature of the work changing. Agents don’t just do the same things faster; they do multiple things simultaneously. They’re testing whilst they code, documenting whilst they implement, considering edge cases whilst they design. The SDLC doesn’t become a straight line from left to right. It becomes a point, or perhaps a very tight spiral, where everything happens in concert.
The Governance Problem
Yet most organisations remain structured around those sequential phases we’ve now lost. Stage gates assume you can pause between phases and make a meaningful go or no go decision. Approval processes assume there’s a stable artifact to approve before the next phase begins. Budget cycles assume you can estimate effort for discrete phases.
What happens when your development team can prototype three architectural approaches before lunch? When can they implement, test, and deploy a feature between morning standup and the afternoon?
This creates an odd paradox. The technology enables radical fluidity, but the governance structures demand artificial rigidity. Teams find themselves either forced to slow down to match the approval cadence, or racing ahead and then retrospectively seeking permission for work already completed. Neither feels satisfactory.
The Illusion of Control
The deeper issue is that stage gates always promised more control than they actually delivered. They created the appearance of methodical progress whilst masking the messy reality underneath: requirements that were never truly stable, designs that evolved during implementation, tests that revealed fundamental misunderstandings.
Agents expose this reality more quickly. When you can iterate rapidly, you discover all the problems that were always there, just faster. The requirements that seemed clear turn out to be ambiguous. The design that looked elegant has unforeseen implications. The integration that should be straightforward hits unexpected edge cases. Stage gates didn’t prevent these problems; they just delayed discovering them.
So perhaps the question isn’t how to fit agent-driven development into existing governance structures, but whether those structures were ever fit for purpose. The stage gate model assumes that thoughtful upfront planning prevents downstream chaos. But software has always been a discovery process, not an execution of a predetermined plan. We’ve simply been pretending otherwise because the long cycles between phases gave us time to forget how much we were making it up as we went along.
Living Without the Left to Right
Do we have a true left to right SDLC now?
No. We never really did, but we could maintain the fiction when phases took weeks or months.
With agents, that fiction becomes impossible to sustain. Development, testing, documentation, and refinement happen concurrently and continuously. The work doesn’t flow through stages; it emerges through rapid iteration and constant feedback.
This doesn’t mean chaos, but it does mean accepting uncertainty as intrinsic rather than exceptional. It means governance based on outcomes and constraints rather than phase approvals. It means trusting teams to navigate complexity rather than pretending we can plan it away.
The uncomfortable truth is that agents haven’t changed the nature of software development so much as revealed what it always was: an exploratory, iterative, simultaneous process of discovery and creation. We built elaborate stage gates and approval processes to make it feel more controlled and predictable. Now that the technology has stripped away the time buffers that made those processes seem to work, we’re left confronting what we were always doing.
We’re building the plane whilst flying it, and we always were. We just used to be able to pretend we’d finished the blueprint first.
To learn more about using AI in the SDLC
We offer AI education workshops, in addition to custom-built AI solutions that deliver new capabilities in a matter of days. Get in touch to discuss.
