The Collapse of the SDLC
Or - how the software industry spent fifty years perfecting a relay race, only to discover it was a sprint, run by one person
Somewhere right now, a project manager is updating a Gantt chart for a feature an AI agent finished last Tuesday. The chart says "Requirements Phase - 3 weeks". The requirements were gathered in a two-hour exhaustive ai interview, turned into a spec before lunch, implemented right after the spec was written, and documented by a different agent while the code was being created, presumably out of politeness.
The Software Development Lifecycle is not dead. It has been compressed from six months into a few afternoons, and nobody has told the process diagrams.
A brief history of standing in line
The SDLC was never a law of nature. It was a coping mechanism.
Phases existed because handoffs existed. Handoffs existed because no single human could hold requirements, architecture, implementation, testing, and documentation in one head at commercial scale. So we invented queues. The business analyst produced a document so the architect could produce a diagram so the developer could produce code so the tester could produce defects so the technical writer could produce a manual nobody read (if you think they had a meaningless job - remember - even today there are people in Munich, putting turn signals ot BMWs).
Every artifact in that chain was a compression algorithm for moving knowledge between brains, and like most compression, it was lossy. Entire methodologies - waterfall, the V-model, RUP, SAFe, LeSS, Scrum@Scale, Nexus, Spotify model, Disciplined Agile, Flight Levels, Team Topologies, FAST, unFIX, pick your acronym - were essentially error-correction protocols for the awkward fact that humans cannot share memory easily.
Agile did not fix this. Agile just made the queue shorter and gave it a daily meeting.
The great compression
Now watch what happens when the handoffs disappear.
An AI agent interviews stakeholders and asks better follow-up questions than most discovery workshops, mostly because it does not get bored, does not check its phone, and has actually read the previous requirements. It drafts the spec. When it has a draft of the spec, it starts implementing against it. While implementing, it writes tests. While writing code and tests, it updates the documentation, which for the first time in software history actually matches the code, because both came out of the same process and spec seconds apart.
Requirements, design, implementation, testing, documentation - no longer five phases. Five threads, running mostly concurrently. The relay race became a single runner, and they run on all the tracks.
The phases still technically happen. They just stopped waiting for each other. Calling this a lifecycle is like calling a lightning strike a warming trend.
The one-person SDLC team
Which brings us to the genuinely unsettling part.
One person can now span the entire lifecycle across multiple applications - gathering requirements in the morning (it's one of the bigges bottle necks and it might be one long morning), shipping in the afternoon, triaging the maintenance tickets an agent filed overnight. Not because that person became superhuman, but because coordination cost - the thing the entire SDLC existed to manage - dropped to approximately zero.
The org chart did not shrink. It collapsed into a bunch of markdiwn files. Business analyst, architect, developer, QA engineer, technical writer, and that one DevOps person who knew where the secrets were kept - all of them now personas a single human orchestrates before the second coffee.
Conway's Law says organizations ship their communication structures. For decades that meant systems shaped like turf wars. Today the communication structure is one person and their agents, and in a twist absolutely nobody predicted, the architecture is finally coherent - there is no one left to disagree with when your context is handed by the orchestrator agent.
Rituals of a religion nobody remembers founding
And yet. Open any project tracker and the phases are still there, glowing softly, like a fax machine in a modern office - technically functional, spiritually decorative.
We hold standups to report on work agents did overnight. We run sprint planning for tasks that will be finished before the meeting ends. We assign story points - a unit of measurement invented specifically to avoid measuring anything - to work whose actual duration is "however long the review takes". Somewhere, a handoff meeting is being scheduled between two roles now occupied by the same person, who will presumably nod at themselves.
Some of this survives for good reasons. Auditors, regulators, and anyone whose software touches money, medicine, or aircraft will rightly demand traceable gates, because "the agent seemed confident" is not yet an accepted entry in a compliance log. But let us be honest about the rest. Most of it survives because process is how organizations feel progress, and dashboards are how managers feel process. We keep the ceremonies for the same reason toddlers get a toy steering wheel in the back seat.
What refuses to collapse
Here the sarcasm has to pause, because something real sits underneath.
The phases collapsed. The work did not. It moved.
Someone still has to decide what is worth building, and no agent can answer that, because "worth" lives in your users, your market, and your appetite for regret. Someone still has to verify - the agent will happily write the tests, but "who tests the tester" has just been promoted from philosophy seminar to job description. Someone still owns the consequences, because you can delegate work to an agent, but you cannot delegate accountability to it, however much the incident review would improve if you could.
Judgment, verification, accountability, taste. These were always the scarce inputs. We just hid them under seventeen job titles and a certification industry. The great irony of the collapse is that we automated the parts we pretended were the hard parts - the typing, the documenting, the ticket choreography - and were left standing face to face with the parts we never staffed properly in the first place.
The SDLC did not collapse into nothing. It collapsed into you.
The loop that remains
What replaces the lifecycle is not chaos. It is a loop - intent, conversation, running software, observation, revised intent. Continuous everything, with a human in the middle acting less like a factory worker and more like an editor-in-chief with strong opinions and root access.
The line is gone. The gates are gone. What remains is a tight circle between a person who knows what should exist and a set of agents that make it exist, at a speed that makes "phase gate" sound like a term from naval history.
Eulogy
So pour one out for the requirements workshop, the design review that approved the wrong design, and the documentation sprint that was forever scheduled and never held. They served honorably, in an era when the bottleneck was communication between humans.
The bottleneck has moved. It now sits between your ears - deciding, checking, and answering for it. Which means the SDLC was never really about software.
It was about people. Remove most of the people, and what is left is not a lifecycle.
It is you, the software, and the uncomfortable discovery that the process was never the hard part.