Agentic AI SDLC vs Traditional SDLC: What Changes

An agentic AI SDLC is a software development lifecycle in which AI agents, not developers, execute the work inside each phase, and humans move to setting intent, approving plans, reviewing outcomes and governing the loop. That one sentence is the whole difference from the lifecycle most enterprises still run. In a traditional SDLC a person does the work and a process checks it. In an agentic AI SDLC the agent does the work, and the only thing left to check is the loop that produced it.

I have spent the better part of this year building multi-agent systems for regulated loan origination, and I keep hearing the term used to mean three different things. So let me separate them first, then get to what actually changes.

Three things people call the same thing

The first is AI-assisted coding. A developer types, the tool suggests, the developer accepts or rejects. GitHub Copilot autocomplete in 2022 is the reference case. The developer is still the executor. The judgment and the code both come from a person, and the lifecycle around them does not move.

The second is vibe coding. Someone describes an outcome in plain English and ships whatever comes back without reading it. It is fine for a weekend prototype. It has no place in a regulated codebase, because it throws away the review discipline that everything else in this post depends on.

The third is the real thing. You hand an agent a ticket, a spec, or an issue. It reads the repository, writes a plan, edits files across the codebase, runs the tests, reads the failures, fixes its own work, and returns a pull request.

Only the third one changes the lifecycle. The first two change a developer’s afternoon.

What the traditional SDLC quietly assumed

Every SDLC I ran for twenty years, waterfall or agile, rested on four assumptions nobody wrote down. A human executes each phase. Review scales with output, because one person can only write so much code in a sprint. The artifacts that carry intent are documents, and documents are read by people. And the gate between phases is a meeting, a sign-off, a ticket moving one column to the right.

None of those survive contact with an agent. The agent executes. Its output volume is limited by budget, not by hours. The artifact that carries intent has to be machine-readable or the agent cannot act on it. And a gate that is a meeting is a gate an agent will never attend.

What actually changes

The unit of work moves from the phase to the loop. Traditional SDLC is a sequence of phases with handoffs. Agentic AI SDLC is a loop: plan, execute, verify, report, repeated until the tests pass or a boundary stops it. Anthropic’s Claude Code now runs that loop explicitly, and GitHub’s Spec Kit formalises the front of it as specify, plan, tasks, implement. The phases still exist. They just happen inside one agent run instead of across three sprints.

Instructions give way to intent. In the old lifecycle the requirements document told a developer what to build and the developer figured out how. In the new one the intent.md file, the spec, and the repository’s AGENTS.md or CLAUDE.md tell the agent what outcome is required and what it may not do. The how is the agent’s problem. This is why I keep saying instructions in, results out was IT, and intent in, outcomes out is agentic AI. People hear a slogan. I mean the literal shape of the file.

Review moves from lines to boundaries. This is the change that catches teams out. When a developer wrote 200 lines a day, a senior engineer could read them. When an agent writes 20,000, nobody can. The answer is not more reviewers. It is boundaries the agent cannot cross, enforced by hooks and gates rather than by eyes.

Evidence is generated, not assembled. In a traditional lifecycle the audit trail is reconstructed after the fact from tickets, emails and commit messages. In an agentic loop every step is a logged tool call, every gate decision is a record, and the spec, plan and task list exist as versioned files before the first line of code. For anyone who has sat through a SOX walkthrough, that is a bigger change than the code generation.

The evidence cuts both ways

I would not trust anyone who tells you this is simply faster. The GitHub and MIT controlled trial found developers finished a greenfield task 55.8 percent faster with Copilot. METR’s randomised trial of sixteen experienced open-source maintainers on their own mature codebases found the opposite: 19 percent slower with AI tools, while the developers themselves believed they had sped up by 20 percent.

Both are right. The gain is largest where the codebase is new and the requirement is clear. It disappears, or reverses, where the system is old and the context lives in someone’s head. Google’s 2025 DORA report found AI raises throughput and hurts delivery stability at the same time, unless the surrounding engineering system is strong. Veracode tested more than a hundred models and found 45 percent of generated code failed basic security tests.

So the acceleration is real and it is conditional. The condition is the loop’s governance, not the model’s benchmark score. Your codebase is the only benchmark that counts.

What I do

In my loan origination work every agent run starts from a committed intent.md that names the ask, the reason and the constraints. Plans get approved before execution. Hooks block the actions the policy forbids, and the pull request cannot merge without a human and an automated reviewer both signing. The agent’s identity is scoped, its sandbox is disposable, and the trail from spec to deploy is a set of files an examiner can read. None of that slows the agent down, which surprised me the first time. It is the reason I can let the agent run at all.

Instructions in, results out was IT. Intent in, outcomes out is agentic AI. The traditional SDLC governed the developer. The agentic AI SDLC governs the loop, and that is the only place governance still has a place.

Which of your SDLC gates is still a meeting an agent will never attend?

My books go deeper on both: Intent In, Outcomes Out and Earned Autonomy.

Go deeper

Agentic AI Architect: control design for enterprise agents.
Agentic AI Case Studies: deployment evidence, one teardown at a time.
Agentic AI P&L: cost, payback, and risk in a CFO’s voice.
Agentic AI Governance: who owns the harness.
Substack first access: agenticaiarch.substack.com/subscribe

Dr. Harish Kotadia, Ph.D., is an Enterprise AI Architect with 20+ years of IT consulting experience serving Fortune 100 clients, specializing in agentic AI systems built on Anthropic Claude, AWS Bedrock, and Google Vertex AI.

Disclaimer: This blog post is based on publicly available academic publications, vendor documentation, open standards, and news items from reputed media sources linked above. This post is intended for educational purposes, to help the enterprise agentic AI community build a shared vocabulary from public, authoritative sources.

Views and opinions expressed here are my own and do not represent those of any employer or client, past or present. The analysis presented is my independent interpretation of the published sources linked above and does not constitute legal, financial, or consulting advice of any kind.