For decades, the software development lifecycle — that familiar procession from requirements gathering through design, coding, testing, deployment, and maintenance — has served as the backbone of how organizations build and ship software. Whether teams followed waterfall, agile, or some hybrid methodology, the fundamental stages remained largely intact. Now, a growing chorus of engineers and technologists argue that the entire framework is becoming obsolete, not because of a new methodology, but because artificial intelligence is collapsing the boundaries between each phase entirely.
Boris Tane, a software engineer and founder, recently published a provocative essay arguing that the traditional SDLC is effectively dead. His central thesis: AI coding agents are not simply accelerating individual steps in the development process — they are merging those steps into a single, fluid act of creation. “The SDLC as we know it is dead,” Tane wrote on his blog. “AI agents don’t follow the SDLC. They collapse it.”
When Machines Don’t Need a Process Chart
Tane’s argument rests on a straightforward observation: when a developer instructs an AI agent to build a feature, the agent doesn’t first write a requirements document, then produce a design spec, then write code, then generate tests. Instead, it does all of these things simultaneously or in rapid, interleaved cycles that bear little resemblance to the sequential or even iterative processes humans have relied on. The AI generates code, tests it, identifies problems, refactors, and redeploys — sometimes in seconds. The phases that once defined professional software engineering are compressed into what Tane describes as a “tight loop” between intent and execution.
This isn’t merely a speed improvement. It represents a structural change in how software comes into being. Traditional SDLC frameworks assumed that different people, or at least different cognitive modes, would handle different stages. Business analysts gathered requirements. Architects designed systems. Developers wrote code. QA engineers tested it. Operations teams deployed it. Each handoff introduced latency, miscommunication, and overhead. AI agents, by contrast, operate as a single entity that holds context across all of these functions. As Tane notes, the agent “doesn’t need a Jira ticket to remember what it’s building.”
The Agile Manifesto Meets Its Own Disruption
The irony is hard to miss. Agile methodology arose in the early 2000s as a reaction to the rigid, documentation-heavy processes of waterfall development. The Agile Manifesto famously valued “working software over comprehensive documentation” and “responding to change over following a plan.” Agile shortened cycles, introduced sprints, and emphasized continuous delivery. But even agile preserved the fundamental stages of the SDLC — it simply made them faster and more iterative. Two-week sprints still contained planning, development, testing, and review phases.
What AI agents are doing, according to Tane and others, is taking the agile philosophy to its logical extreme — and then going further. If agile said “iterate quickly,” AI agents say “iterate instantly.” If agile said “reduce documentation overhead,” AI agents say “eliminate it entirely, because the code is the documentation and the test and the deployment artifact all at once.” The sprint, that fundamental unit of agile work, may itself become an anachronism when an AI can ship a feature in the time it takes a scrum master to open a meeting.
What Happens to the Engineers?
The implications for software engineering as a profession are significant and, for many practitioners, unsettling. Tane is careful to note that human engineers are not becoming irrelevant. Rather, their role is shifting from writing code to directing AI agents — defining intent, reviewing output, and making judgment calls about architecture, security, and user experience. He compares the emerging role to that of an editor rather than a writer, or a director rather than an actor.
This reframing has been echoed across the industry. In March 2025, Anthropic CEO Dario Amodei told audiences that he expects AI to write the vast majority of code within the next year. Satya Nadella, Microsoft’s CEO, has made similar predictions, suggesting that AI-generated code already accounts for a growing share of commits at Microsoft. GitHub’s own data shows that its Copilot tool has been used to generate billions of lines of code since its launch. The question is no longer whether AI will write most software — it’s what happens to the processes and people that were built around the assumption that humans would.
The Testing Paradox and Quality Assurance in an Agent-Driven World
One of the most interesting dimensions of the SDLC’s collapse involves testing and quality assurance. In the traditional model, testing was a distinct phase — often the bottleneck in any release cycle. QA teams would write test plans, execute test cases, file bugs, and verify fixes. Even in agile shops with strong test automation, testing remained a recognizable, separate activity.
AI agents, however, tend to generate tests as part of the code-writing process itself. When an agent like Cursor, Devin, or Claude Code builds a feature, it often produces unit tests, integration tests, and sometimes even end-to-end tests alongside the production code. Tane points out that this collapses the traditional feedback loop between development and QA. The agent doesn’t “throw code over the wall” to a testing team. It tests its own work, identifies failures, and corrects them before a human ever sees the output. This raises a philosophical question that the industry has not yet fully answered: who validates the validator? If an AI writes both the code and the tests, what independent check ensures correctness?
The Organizational Ripple Effects
Beyond individual engineering workflows, the death of the traditional SDLC has profound implications for how software organizations are structured. The SDLC wasn’t just a technical process — it was an organizational one. Companies built entire departments around its stages: requirements teams, architecture review boards, development groups, QA divisions, release management offices. If those stages collapse into a single AI-driven workflow, the organizational structures built around them face an existential question.
Tane suggests that the future software team may look radically different from today’s. Instead of large, specialized groups organized by function, companies may field small teams of “AI wranglers” — engineers who are expert at prompting, directing, and reviewing AI output. The ratio of engineers to shipped features could change dramatically. A team of three people working with AI agents might produce what previously required thirty. This isn’t speculation; early reports from companies experimenting with AI-first development, including startups and some divisions within larger firms, suggest that productivity gains of 3x to 10x are achievable for certain types of work.
What the SDLC’s Demise Doesn’t Change
For all the disruption, some things remain stubbornly constant. Software still needs to meet user needs. Systems still need to be secure, reliable, and maintainable. Regulatory and compliance requirements don’t disappear because an AI wrote the code — if anything, they become more complex when organizations need to explain and audit AI-generated artifacts. The human judgment required to make architectural trade-offs, to understand business context, and to make ethical decisions about what software should and shouldn’t do remains firmly in human hands.
Tane acknowledges this in his essay, writing that the collapse of the SDLC doesn’t mean the end of engineering discipline. It means the discipline must evolve. Engineers will need new skills: the ability to evaluate AI output critically, to design effective prompts and constraints, to understand system behavior at a higher level of abstraction. The mechanical act of typing code may diminish in importance, but the intellectual act of designing systems — understanding what to build, why, and what trade-offs to accept — becomes more important, not less.
The Industry Hasn’t Caught Up Yet
Perhaps the most striking aspect of this moment is the gap between what’s technically possible and how most organizations actually operate. The vast majority of software companies still run sprints, hold standups, maintain Jira boards, and follow some version of the SDLC. Job postings still ask for experience with agile methodologies. Certifications in Scrum and SAFe remain popular. The institutional inertia is enormous.
But as Tane and others argue, the pressure is building. Companies that adopt AI-first development practices are shipping faster and with fewer people. Competitive dynamics will eventually force the rest of the industry to follow. The SDLC, like the waterfall model before it, won’t disappear overnight. It will fade gradually, its rituals persisting long after their original purpose has been superseded. The standup meeting may survive as a social ritual even after the sprint it was designed to support has lost its meaning. The Jira board may persist as a communication tool even after the workflow it tracks has been automated away.
What replaces the SDLC is still taking shape. It may not have a catchy acronym or a manifesto signed at a ski lodge. But its outlines are becoming visible: a world where the distance between an idea and working software approaches zero, where the role of the engineer shifts from producer to curator, and where the processes that defined a profession for half a century quietly become artifacts of a slower era.