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.

PhaseWhat AI doesWhat people still ownWhat goes wrong
PlanDrafts requirements and user stories, splits work into tasksWhat is worth buildingA convincing spec for the wrong problem
DesignProposes architectures, data models and interfacesWhich architectural decisions bind the systemA design that contradicts a decision already made
ImplementWrites, refactors and migrates code across many filesWhat a change is allowed to touchCode that runs but crosses a service boundary
TestWrites tests and runs them until they passWhether the tests check the right behaviourTests written to pass, not to catch mistakes
ReviewSummarizes diffs and flags likely problemsApproving changes and granting exceptionsMore code arriving than reviewers can read
MaintainUpgrades dependencies, writes docs, helps triage incidentsLong-term direction of the codebaseEach 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.

LevelWho starts the workWhere a person checksTypical tools
AI-assistedA developer; AI suggestsEvery change, in the editorAutocomplete, chat assistants
AI-drivenAn agent, given a taskAt the pull requestCoding agents such as Claude Code, Cursor and Codex
AI-nativeAgents, working from committed files such as a spec or a planAt set approval points between stages, plus automated checks on every changeSpec-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.

FrameworkFromStructureWhere people approve
AI-DLC (AI-Driven Development Life Cycle)AWS, July 2025Three 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 playbookAnthropic, August 2026Six stages with committed artifacts: intent.md, spec.md, plan.md, the pull request with its review findings, and a new intent.md after an incidentAt the gates between stages; hooks enforce the rules that must always hold
BMAD MethodOpen source (MIT)"Breakthrough Method for Agile AI-Driven Development": brings in product, architecture, UX, development and testing roles as the work needs themThe user directs the agents; BMAD makes key decisions explicit and carries them forward as context
Spec KitGitHub, open source (MIT)Spec-driven development: a constitution (the project’s principles), then specify, plan, tasks and implement, among other stepsThe 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

  1. 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.
  2. 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.
  3. 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.
  4. Keep people where judgment matters. Scope, exceptions and releases need a named person; routine conformance does not.
  5. 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.
Where step 3 puts each check. Context guides the agent; the hook and the CI check can block a change; an audit only finds what slipped through.

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.

Agent-side checks
Checks each Claude Code edit against recorded decisions before it lands; exports the same decisions as Cursor rules.
Deterministic enforcement in CI
Checks each pull request against recorded decisions and blocks or warns, depending on mode.

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.