Fundamentals

What Is ADLC? The Software Development Lifecycle When AI Agents Write the Code

Người đang viết chữ ADLC lên bảng trắng
In this article

    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.

    What is ADLC?

    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?”

    The 6 phases of ADLC

    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.

    1. State the intent and requirements (Intent and requirements): The human states the goal, the constraints, and what “done” looks like. The agent reads the existing documentation, drafts user stories (requirements described from the user’s point of view), and points out where the requirements are still missing or contradictory. The clearer the intent, the more on track every step after it stays.

      The shop owner types a single line: “customers type in an order code and see the delivery status.” The agent asks back: “What should it say when a customer mistypes a code?” Only then does the owner realise he hadn’t thought about that case.
    2. Design (Design and architecture): The agent proposes the architecture, the data model (how the data is organised), and how to integrate. The human picks the direction and sets guardrails: security, code standards, the things the agent must not touch.

      The agent suggests reading the status from the existing orders table. The owner settles one thing right away: don’t touch the database structure.
    3. The agent writes the code (Build): Specialised agents write code in parallel, each agent with a clear role. The human no longer writes every line but reviews at checkpoints (planned stops for review) that were agreed in advance.

      The agent builds the code-entry box and the lookup function, while the owner only stops to look at each agreed checkpoint.
    4. Test and verify (Test and verify): The agent generates tests and runs them continuously while building, so testing is no longer a separate phase at the end. Phase 4 keeps its name in the list of 6 phases, but the right way to understand it is testing running throughout the build — not a checkpoint squeezed in at the end. The human focuses on what automation tends to miss: business logic, edge cases, security risks.

      The owner tries one more case the agent hadn’t thought of: the code of an order that was cancelled.
    5. Review and release (Release): The agent prepares the pipeline (the automated deployment process), the documentation, and the release notes (notes on what changed). The human reviews and decides on go-live (switching it on for customers to use), especially for high-risk changes — every step leaves an audit trail (a traceable history).

      For the order-tracking page, when it is time to switch it on in the real shop, the owner is the one who clicks the button.
    6. Operate and improve (Operate and improve): The agent watches performance, sorts issues, and proposes fixes. The human approves before anything is applied, and what is learned from production feeds back in as requirements for the next round.

      After a few weeks, the agent reports that many customers mistype the code format. It suggests adding a hint line under the input box, and the owner approves it before it is applied.

    In file terms, the 6 phases above can leave behind a chain of artifacts, one after another, for example:

    • intent.md: records what to build.
    • spec.md: records the spec and the design approach.
    • plan.md: records the rollout plan.
    • code with tests: the result of the build phase.
    • review record: records the outcome of review and approval.
    • production signal: records incidents and operating metrics.

    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.

    Six phases of the Agentic Development Life Cycle, the agent writes the code and the human reviews the result
    The ADLC loop, 6 phases — the agent does each phase, the human reviews at checkpoints

    How do SDLC and ADLC differ?

    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.

    SDLCADLC
    Who does the workDevs, testers, analysts do each job by handThe agent writes code, tests, docs; the human directs and reviews
    How it runsPhases one after another, or short sprintsA continuous loop, phases overlapping
    The main bottleneckThe team’s capacity, the review queueHow clear the requirements are, and how good the review is
    The skill that matters mostWriting code and reviewing codeStating intent, setting guardrails, checking the agent’s output
    Quality controlOne separate test phase before releaseAutomated checks at every step, plus human review at checkpoints
    ResponsibilityThe person who wrote the code is responsibleThe 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.

    How do you start with ADLC?

    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.

    Frequently asked questions

    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.

    Conclusion

    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.

    Sources

    The references below were opened and checked on 20 November 2026.

    Assistant Gnurt

    Full-stack developer

    Discuss your project

    Comments

    No comments yet. Be the first!