What Is SDLC? 6 Phases and 3 Software Development Models
What is SDLC? The 6 phases of software development and 3 models — Waterfall, Agile, Spiral — explained through a small online shop.
In the earlier article about SDLC, I walked through SDLC with a small online shop as the example: plan, design, code, test, then deploy — everything running smoothly.
Then the shop owner wants a new feature: an order-tracking page, where customers type in an order code and see the delivery status. This time, instead of writing every line of code himself, he describes the request to an AI agent and lets the agent do it: the agent reads the existing code on its own, writes new code, runs tests, then opens a pull request — a request to merge code, for someone to look at before it is merged. The human is left with three jobs: describe the request clearly, set guardrails (limits) for the agent, then read the result and click merge (merge the code into the main branch).
That way of working has a name: ADLC. So what is ADLC, and how is it different from SDLC? The familiar phases of SDLC don’t disappear — only the person doing them changes.
So what is ADLC? ADLC (Agentic Development Life Cycle) is the software development lifecycle in which an AI agent does most of the work at each phase: planning, writing code, testing, and deploying. The human keeps three jobs: saying clearly what to build, setting guardrails for the agent, and reviewing the result before it reaches production (the live environment customers are actually using).
The agent here means coding agents like Claude Code, Codex, or GitHub Copilot: they can read a whole repo, run commands, edit files, and iterate on their own until the job is done, instead of merely suggesting one line of code at a time like the assistive tools before them.
One point worth clearing up right away, because I got it wrong myself at first: ADLC has two meanings in use today. The first — the one this article uses — is Agentic Development Life Cycle: the agent writes code instead of the human. The second is Agent Development Lifecycle, the way IBM and some other companies use it: the lifecycle for building and running the AI agent itself. They are different things, so when you read an article about ADLC, the first thing to check is which meaning the author is using.
Why is ADLC showing up now? Because coding agents are finally good enough to finish a whole task, not just suggest. When that happens, the question is no longer “can an agent write code?” but “how does the workflow have to change when the one writing the code is an agent?”
ADLC has no single agreed standard yet — some companies split it into 6 phases, others into 9 — but the 6-phase frame below is fairly common, and it keeps the familiar phases of SDLC. The difference is who does them and how they connect: no longer a straight line, but a continuous loop, with feedback from production feeding back in as requirements for the next round.
In file terms, the 6 phases above can leave behind a chain of artifacts, one after another, for example:
Each artifact is both the result of one step and the input to the next. A production signal, for instance, can come back as a new requirement for the next round. Thanks to this chain, the goal is written down somewhere, design decisions have a basis, and every change has a history.

Overall, ADLC keeps SDLC’s goal but changes how the work is divided between the human and the agent, within clear limits. The table below compares the points that change the most.
| SDLC | ADLC | |
|---|---|---|
| Who does the work | Devs, testers, analysts do each job by hand | The agent writes code, tests, docs; the human directs and reviews |
| How it runs | Phases one after another, or short sprints | A continuous loop, phases overlapping |
| The main bottleneck | The team’s capacity, the review queue | How clear the requirements are, and how good the review is |
| The skill that matters most | Writing code and reviewing code | Stating intent, setting guardrails, checking the agent’s output |
| Quality control | One separate test phase before release | Automated checks at every step, plus human review at checkpoints |
| Responsibility | The person who wrote the code is responsible | The person who clicks merge is responsible — the agent doesn’t take the blame |
Three differences from the table are worth remembering most.
First, the most important skill changes from writing code to writing requirements. In SDLC, the good person is the one who codes fast and solidly. In ADLC, the agent handles the typing, and the human has to describe clearly what they want: the goal, the limits, the done criteria. A vague requirement makes the agent do the wrong thing very fast — faster than a human, because the agent usually keeps going instead of stopping to ask.
Second, review becomes the new bottleneck. The agent produces far more code than one person typing by hand, so reading and carefully reviewing each diff (the changed part of the code) is a job that can’t be delegated to anyone. According to AgentQueue, citing a LeadDev analysis (July 2026, across 25,264 agent-created pull requests), in 79% of cases the same person both assigned the work to the agent and reviewed it themselves — meaning the most important control loop rests on one person grading their own homework.
For ADLC to run safely, review has to be designed properly: review the agent’s whole working session (what commands it ran, whether the real tests actually passed), not just the final diff, and for important changes bring in a second person.
Third, responsibility doesn’t change hands. ADLC changes who types the code, not who answers for it. The agent writes the code, but the person who clicks merge is the one who answers when production breaks. Once you understand that, you can dare to hand the agent bigger jobs, because you know where the limits have to go.
By now you may think ADLC sounds like something for big teams. But one person building websites alone can start with the same three steps.
Step 1: Write a clear spec before handing work to the agent.
Before asking the agent to do anything, write down in plain language: what to build, which files it may change, which places it must not touch, and what “done” looks like. For example: “add an order-tracking page, only change files in the orders folder, don’t change the database schema, done when a customer types in an order code and sees the correct delivery status.” A clear spec is the cheapest guardrail there is.
Step 2: Let the agent work on its own branch, review every diff.
The agent works on its own branch, opens a pull request, and every change has to pass review before it is merged. The agent doesn’t merge, and doesn’t push straight to production. This habit keeps the final decision with you — and it also teaches you where the agent tends to go wrong, so your next spec is better.
Step 3: Start with something small.
Don’t hand over a whole project at once. Hand over one small feature or one bug fix, run the whole loop once: write the spec, let the agent do it, review the diff, try it out, deploy. Learn from that loop, then widen it to bigger jobs. ADLC doesn’t need to be fully learned before you start — start with one small loop, and the process gets clearer with each round.
Does ADLC replace SDLC?
No. ADLC keeps SDLC’s phases, only changing who performs them. SDLC is still the frame; ADLC is the way to run that frame when the agent writes the code.
Should I learn SDLC or ADLC first?
SDLC first. ADLC runs on the SDLC frame — once you understand what each phase does and what a verifiable output looks like, you know which parts to hand to the agent and which to keep.
Does ADLC have a common standard yet?
Not yet. Companies split the phases differently — 6 or 9 — and the term still carries the two meanings mentioned at the start of this article. When you read ADLC material, check which meaning the author is using: the agent writing code instead of the human, or the lifecycle for building and running the agent itself.
SDLC answers the question of how to build software reliably. ADLC adds one more question: when the one writing the code is an agent, what role does the human still keep — stating the intent, setting the limits, and reviewing the result.
If you are already using a coding agent, try handing it one small job following the three steps above: write a clear spec, let it work on its own branch, review each diff before merging. One small loop like that gives you a better feel for ADLC than any definition.
After that, you can read What Is Harness Engineering and What Does a Harness Include? to understand how to organise the environment and the control mechanisms that let an agent work safely. A harness is an important part of ADLC once the agent is in operation.
The references below were opened and checked on 20 November 2026.
Comments
You can use your Google account to comment. Google only shares your verified name and email address to display your name. You can log out at any time.
Sign in with GoogleNo comments yet. Be the first!