The six phases of the AI SDLC
The traditional lifecycle has six phases: plan, design, implement, test, review and maintain. In the AI SDLC each phase gains an AI participant. The table shows what the AI does in each phase, what people still decide, and the failure that phase is most exposed to.
| Phase | What AI does | What people still own | What goes wrong |
|---|---|---|---|
| Plan | Drafts requirements and user stories, splits work into tasks | What is worth building | A convincing spec for the wrong problem |
| Design | Proposes architectures, data models and interfaces | Which architectural decisions bind the system | A design that contradicts a decision already made |
| Implement | Writes, refactors and migrates code across many files | What a change is allowed to touch | Code that runs but crosses a service boundary |
| Test | Writes tests and runs them until they pass | Whether the tests check the right behaviour | Tests written to pass, not to catch mistakes |
| Review | Summarizes diffs and flags likely problems | Approving changes and granting exceptions | More code arriving than reviewers can read |
| Maintain | Upgrades dependencies, writes docs, helps triage incidents | Long-term direction of the codebase | Each fix drifting further from the original design |
Implementation speeds up the most, because agents write code far faster than people do. The cost lands downstream. Review still runs at human speed, so review cannot keep up with AI output, and decisions that used to live in reviewers' heads stop being applied consistently unless something checks every change against them.
AI-assisted, AI-driven and AI-native
Teams use these labels loosely, and "AI-powered" or "AI-enabled" SDLC usually means the first of them. The useful difference is who starts the work and where a person checks it.
| Level | Who starts the work | Where a person checks | Typical tools |
|---|---|---|---|
| AI-assisted | A developer; AI suggests | Every change, in the editor | Autocomplete, chat assistants |
| AI-driven | An agent, given a task | At the pull request | Coding agents such as Claude Code, Cursor and Codex |
| AI-native | Agents, working from committed files such as a spec or a plan | At set approval points between stages, plus automated checks on every change | Spec-driven workflows, pre-edit hooks, CI checks |
In an AI-native SDLC, each stage ends by committing a file to the repository, called an artifact: an intent, a spec, a plan, or a diff with its tests. The next stage starts from it. Agents do the work between those artifacts, and a person approves at set points instead of at every step. So the rules an agent must follow have to be checked automatically on every change it makes, not only when a reviewer reads the result. Anthropic's playbook is the most detailed published version of this model; see Anthropic’s AI-Native SDLC Playbook, Summarized and Extended.
AI SDLC frameworks and methodologies
There is no single standard AI SDLC framework. Four published approaches illustrate the range. Each puts structured, written artifacts between AI steps, and most keep people approving at defined points.
| Framework | From | Structure | Where people approve |
|---|---|---|---|
| AI-DLC (AI-Driven Development Life Cycle) | AWS, July 2025 | Three phases: Inception, Construction, Operations, worked in short cycles AWS calls "bolts" | The team validates AI proposals in group sessions ("mob elaboration" and "mob construction") |
| AI-Native SDLC playbook | Anthropic, August 2026 | Six stages with committed artifacts: intent.md, spec.md, plan.md, the pull request with its review findings, and a new intent.md after an incident | At the gates between stages; hooks enforce the rules that must always hold |
| BMAD Method | Open source (MIT) | "Breakthrough Method for Agile AI-Driven Development": brings in product, architecture, UX, development and testing roles as the work needs them | The user directs the agents; BMAD makes key decisions explicit and carries them forward as context |
| Spec Kit | GitHub, open source (MIT) | Spec-driven development: a constitution (the project’s principles), then specify, plan, tasks and implement, among other steps | The developer reviews each step’s output before running the next |
The frameworks differ in vocabulary more than in shape. All four turn intent into written requirements, a plan and then code. In each, architectural decisions mostly live in documents the agent reads, such as a constitution, an architecture document or a context file. A document the agent reads is guidance, not a check. Whether a given change respects those decisions is left to the team or to advisory review passes; none of the four checks each change against recorded architectural decisions with a rule that gives the same answer every time. That is the gap spec-driven development still leaves open.
Benefits and risks
Benefits. The gains are real when the work is well specified:
- Faster implementation of clearly scoped changes.
- Specs, plans and decisions written down, because agents need them as input.
- Tests written as a matter of routine rather than when there is time.
- Cheaper maintenance chores: dependency upgrades, migrations, documentation.
Risks. Most of them come from output growing faster than the team's ability to check it:
- Review overload. Pull requests arrive faster than people can read them, and approval turns into a formality.
- Architectural drift. Each change is locally reasonable, but together they move the system away from decisions the team made.
- Weak verification. Tests that confirm what the code does rather than what it should do; see the verification tax.
- Rework. Time saved writing code is spent fixing it later; see productivity gains and rework.
How to adopt an AI SDLC
- Write down the decisions agents must follow. Service boundaries, approved libraries and data-access rules belong in architecture decision records (ADRs), not in reviewers' memory. See how AI coding agents use ADRs.
- Choose the artifacts each stage hands on. An intent, a spec, a plan, a diff with tests. Committed artifacts give every later step, and every auditor, the same starting point.
- Separate advice from rules that must hold. Conventions can live in context files the agent reads. Rules that must never break need a check that runs before the change lands and gives the same answer every time, such as a hook in the agent or a check on the pull request. This is deterministic enforcement.
- Keep people where judgment matters. Scope, exceptions and releases need a named person; routine conformance does not.
- Measure outcomes, not output. Track rework, defects found after release and review time alongside throughput, so speed in one phase does not hide cost in another.
Five enforcement checkpoints · two fire before generation
Five lifecycle checkpoints. Pre-generation governance: IDE corpus as context, and pre-tool-use hook that blocks before the agent writes. Post-generation checks: CI check (the hard gate that blocks before merge), Merge gated on the verdict, and post-hoc Audit review.
Where Mneme fits
Mneme is not a new SDLC. It builds the decision and control layer that an AI SDLC needs, starting with architecture: recorded decisions, checked against the changes agents propose.
Because the same decisions drive both, a rule is checked at edit time in agents that support pre-edit hooks, and again at the pull request whichever agent wrote the change.