What Is AI-DLC? The AI-Driven Development Life Cycle, From Inside a Rollout
AI-DLC is the AWS method where the AI drives the work and humans decide at the gates. What it is, how AI-DLC 2 runs today (5 phases, 33 stages, 14 agents, the 2.11 defaults), how it differs from Anthropic's AI-native SDLC playbook, when not to use it, and why Spec-Driven Development has to come first. Written from inside a real rollout.
In AI-DLC the AI drives and the human decides. Every other part of the method exists to keep the second half of that sentence honest.
AI-DLC, the AI-Driven Development Life Cycle, is a method for building software in which an AI agent plans the work, asks the questions, and writes every artifact, from requirements to code, while humans approve or reject the result at gates between the steps. AWS published it in July 2025. Since June 2026 it also ships as AI-DLC 2, an open-source workflow engine that runs inside Claude Code, Kiro (CLI and IDE), Codex, Cursor, opencode, and GitHub Copilot. The current release is 2.11.0, from October 8, 2026: five phases, 33 stages, 14 agents.
It is not Anthropic’s AI-native SDLC playbook. That is a different document from a different company, and people mix them up; the difference has its own section below.
I have written about Spec-Driven Development for a year and built a 13-app fintech in 70 days by specifying before generating. For the last few months I have also been inside a large engineering organization where AI-DLC moved from pilot squads to a training program for the people who will spread it to every team. Everything below comes from the public method, the current release, and that rollout, with the names taken out.
AI-DLC is a method, not a tool
Start with the thing people get wrong first. AI-DLC is a way of organizing software work around an AI agent. AWS describes it as a methodology, and the independent analyses agree. TT PSC’s writeup put it in one line: the contribution of AI-DLC “is not code generation itself”, it is “a controlled operating model where AI participates throughout Inception, Construction, and Operations, while humans remain accountable for decisions.”
The tool came later. The original release in November 2025 was a set of rules files for Amazon Q and steering files for Kiro. AI-DLC 2 turned it into an engine with its own command, aidlc, that installs the workflow into the coding agent you already use. AWS calls each of those agents a harness: Claude Code is one, Cursor is another. You can practice the method without the engine. You cannot get value from the engine without the method.
AI-DLC 2 at a glance
- phases
- 5
- Initialization to Operation
- stages
- 33
- each with a lead agent
- agents
- 14
- 11 experts, 2 reviewers, 1 composer
- harnesses
- 7
- Claude Code, Kiro, Codex, Cursor and more
The AI asks the questions and you decide
The core of the method is one inversion. In ordinary AI-assisted work, you start the conversation. You write the prompt, the AI helps with a task, and the process around it stays the one your team already had. In AI-DLC the AI starts. You give it an intent, and it proposes the plan, asks what it needs to know, drafts the artifact, and stops for your approval before it moves on.
The whitepaper uses a navigation app to explain it. You set the destination. The app gives you the turns. You still watch the road and you can take another street, but you stopped reading the map.
AI-assisted development
- 01You write the prompt and the AI answers
- 02The AI helps on one task at a time
- 03The process is the one built for humans
- 04Decisions live in chat history
AI-DLC
- 01You state an intent and the AI asks the questions
- 02The AI proposes the plan and the decomposition
- 03The process is rebuilt around the AI's speed
- 04Decisions live in versioned files in the repo
This changes what good work looks like for you. You no longer win by writing the perfect prompt. You win by answering the right questions with the right context, and by refusing to approve what you cannot explain.
Why AWS says you cannot bolt AI onto Scrum
The first principle in the whitepaper is to reimagine rather than retrofit. The argument is simple and I think it is correct. Scrum was built for a team of humans who need two weeks to produce a working increment, so it has rituals sized to that pace: planning, dailies, reviews, retros. An agent produces the same increment in hours. Keep the two-week rituals and the agent spends most of its life waiting for a meeting.
The paper names the two failure modes on either side. AI-assisted development keeps the old process and adds autocomplete, so it never changes the structure of the work. AI-autonomous development lets the agent build alone, which does not work yet, because context and critical decisions still depend on a person. AI-DLC is the middle: the AI drives, the human approves.
The vocabulary: Intent, Unit, Bolt
AI-DLC renamed the parts of the work on purpose. The whitepaper’s seventh principle says a practitioner should be able to start in a single day, so every new term maps to an old one.
Old words, new words
| AI-DLC term | What it replaces | What it means |
|---|---|---|
| Intent | Business epic | A statement of what needs to be achieved and why. The starting point the AI decomposes. |
| Unit | Technical epic | A self-contained piece of the solution that delivers measurable value and can be built and deployed on its own. |
| Bolt | Sprint | A delivery slice measured in hours or days, not weeks. In AI-DLC 2, a planned slice over one or more dependent Units. |
| Mob Elaboration | Planning and refinement | The team and the AI in one session: the AI proposes stories and Units, the team corrects them. |
| Mob Construction | Coding, review, testing | The AI generates design, code, and tests; engineers approve or request changes at each step. |
| Deployment Unit | Release candidate | Code, configuration, and infrastructure tested for function, security, and non-functional requirements. |
One old idea moved house: steering files. In version 1 they were markdown files in the repository that told Kiro or Amazon Q the rules of the project. In AI-DLC 2 the same job belongs to rules kept in a memory folder, layered from organization to team to project to phase, and every harness loads them on its own.
Two of the terms in the table deserve a second look. The Intent is the one input a human must get right, and the method says almost nothing about how to get it right. That gap is big enough that it gets its own article. And Mob Elaboration is where most of the value and most of the pain live. It is a ritual, with rules about who sits in the room, and it has its own guide.
Five phases and 33 stages in AI-DLC 2
The first version of AI-DLC had three phases: Inception, Construction, and Operations. AI-DLC 2 has five. It added Initialization, which sets up the workspace in under a second with no human involved, and Ideation, which turns a vague request into an approved initiative before any requirements are written.
The AI-DLC 2 lifecycle
- 0.1 to 0.3
Initialization
Scaffolds the workspace, detects the project, creates state. Automatic.
- Workspace Scaffold
- Workspace Detection
- State Initialization
- 1.1 to 1.7
Ideation
Is this worth building, and what exactly is it?
- Intent Capture and Framing
- Market Research
- Feasibility
- Scope Definition
- Team Formation
- Rough Mockups
- Approval and Handoff
Gate: Verification gate 1
- 2.1 to 2.9
Inception
Requirements, design, and the Units of work.
- Reverse Engineering
- Practices Discovery
- Requirements Analysis
- User Stories
- Refined Mockups
- Domain Design
- Units Generation
- Contract Design
- Delivery Planning
Gate: Verification gate 2
- 3.1 to 3.7
Construction
Design, code, and tests, one Unit at a time.
- Functional Design
- NFR Requirements
- NFR Design
- Infrastructure Design
- Code Generation
- Build and Test
- CI Pipeline
Gate: Verification gate 3
- 4.1 to 4.7
Operation
Deploy, observe, and feed what you learn back into Ideation.
- Deployment Pipeline
- Environment Provisioning
- Deployment Execution
- Observability Setup
- Incident Response
- Performance Validation
- Feedback and Optimization
Two kinds of checkpoints run through that map, and the difference matters. At the end of each stage your profile runs there is an approval gate: you answer Approve or Request Changes, in your own words, and nothing moves until you do. Between phases there is a verification gate: an automated check that every requirement maps to a story, nothing is orphaned, and the artifacts agree with each other. The first catches bad judgment. The second catches broken links.
Construction bends the first rule, and many explainers miss it. By default the engine walks one Unit at a time through its design stages and code, and you approve each Unit at one checkpoint instead of approving every stage. Construction also offers Continue automatically, which lets the engine move on after each Unit without asking, and then the ordinary completion checkpoints go away too. What still stops you: the code plan (unless plan approval is off for that work), the summary confirmation if it is on, the walking-skeleton approval, your choice of the command that proves a Unit works, and every failure. Nothing in a profile or a setting lets the agent approve a gate on your behalf; the docs require a real message from a person, and only a machine-wide bypass flag lowers that.
Each stage has a lead agent. AWS ships 14 of them: 11 domain experts (product, design, delivery, architect, AWS platform, compliance, DevSecOps, developer, quality, pipeline and deploy, operations), two reviewers that judge requirements and technical design, and a composer that assembles custom routes. The design principle is “Small Mob, Broad Agents”: a few broad agents instead of dozens of narrow specialists, because a chain of narrow specialists is just waterfall handoffs with better marketing.
Most stages run inline, in your conversation with the agent. Four are built differently. Reverse Engineering is a two-step pipeline (a developer agent scans the code, an architect agent writes the synthesis). Practices Discovery and Code Generation run as dispatched subagents. User Stories is designed as an agent mob (agents, not people; the human ritual is Mob Elaboration), with the design, developer, and quality agents writing in parallel.
Since 2.11.0 that agent mob is opt-in. Every stage has a lead agent and may list support agents that review or contribute, like the DevSecOps agent on a design stage. Those support agents only join when the collaborators setting is on, and it ships on only for the enterprise profile. Everywhere else each stage runs with its lead agent, and /aidlc --collaborators on brings the others back for one piece of work. Either way, everything gets written to a per-intent folder in your repo, with a state file and an append-only audit log of 115 event types in 25 categories (the 2.11.0 docs, checked October 13, 2026).
The most important design choice in AI-DLC 2 is not on that map. The route through it is decided by a deterministic engine, plain code, and not by the model. The model does the thinking inside each stage. The engine decides which stage runs next, a Unit only counts as verified through a check command a human approved, reviewers are separate agents, and guards stop the model from moving the workflow state on its own. Version 1 trusted the agent to follow prose rules, and slop comes from exactly that trust: a model that routes itself and grades its own work. Version 2 took those powers away. Since 2.11 most profiles start with some of those guards lowered (more on Guard Policy below), and the docs call the audit write guard a guardrail, not a security boundary. What no setting lowers is the human gate.
The details of what changed between the versions, and which homegrown workarounds AI-DLC 2 made obsolete, are in AI-DLC 2: what changed.
A bugfix does not need 33 stages
The tenth principle of the original whitepaper is the one I would keep if I could keep only one: no hard-wired workflows. A bug fix does not need domain modeling. A new feature does. The AI should propose how deep to go, and the human should adjust.
AI-DLC 2 turned that principle into 11 workflow profiles (the docs call them scopes). You name one, or you describe the work and the engine suggests one.
Workflow profiles in AI-DLC 2
| Profile | Stages | Use it for |
|---|---|---|
| Classic | 18 / 33 | Version 1 ceremony: Inception and Construction, one approval per stage. The default when you name nothing. |
| Express | 10 / 33 | Requirements already clear. Lightest path from requirements to code and tests. |
| Feature | 33 / 33 | A production feature through the whole lifecycle. |
| Enterprise | 33 / 33 | Regulated or high-risk work. Comprehensive depth and the strictest guards. |
| MVP | 23 / 33 | A real first increment, without the Operation phase. |
| Proof of concept | 8 / 33 | Can this work at all? |
| Bugfix | 9 / 33 | A known defect, a focused fix, a regression test. |
| Refactor | 10 / 33 | Change the structure, keep the behavior. |
| Infrastructure | 13 / 33 | Environments, IaC, pipelines, cost. |
| Security patch | 10 / 33 | A CVE or a narrow vulnerability. |
| Workshop | 26 / 33 | A facilitated training session. |
Release 2.11.0 also trimmed the ceremony inside the profiles. Every profile except enterprise now starts new work with Guard Policy off. Guard Policy does not decide which gates you see. It decides how hard the engine’s fences hold. Under strict all five stay up. Under off four come down (plan re-approval, review freeze, state transition, reviewer read scope), each lowering still written to the audit log; only the human-presence fence and Unit ownership never move. The effect you notice: under strict an edited plan goes back for approval, under off you get one line saying what changed and the run continues, and you can approve over a review that has not finished. The other new switch is /aidlc --plan-approval on|off, which decides whether the code plan needs your approval before code is written. It ships off in express and poc and on everywhere else, and the agent can never turn it off for you. If your team needs the old strictness, a Mode: strict line in the team’s memory file holds it for everyone. Source: the 2.11.0 release notes, checked October 13, 2026.
And there is a twelfth answer the table does not list: do not use AI-DLC at all. In the rollout I followed, one engineer ran the full ritual to change a single line of code. The internal playbook soon got a new rule, contributed by someone from the pilot: if you already know exactly what to type, type it. AI-DLC pays when the work needs decomposition and decisions from more than one person. Below that, the ceremony costs more than it saves.
Ten principles, and the one AI-DLC 2 strains
The whitepaper, written by Raja SP at AWS, rests on ten principles. Most explainers list them. The more useful question is which ones the shipped engine kept, because the engine is what your team will actually run.
The ten AI-DLC principles against release 2.11.0
| # | Principle | What it asks | In AI-DLC 2.11 |
|---|---|---|---|
| 1 | Reimagine rather than retrofit | Design the process around AI, not AI into the old process. | Kept. Bolts replace sprints; five phases replace the ceremony calendar. |
| 2 | Reverse the conversation direction | The AI plans and asks; the human answers and approves. | Kept. Every stage asks its questions, then stops at an approval gate. |
| 3 | Design techniques in the core | DDD, BDD and TDD are part of the method, not a team choice. | Kept as stages: Domain Design, Functional Design, NFR Design, Build and Test. |
| 4 | Align with AI capability | AI is not fully autonomous yet, so humans validate. | Hardened. A deterministic engine routes the work, and a gate needs a real message from you. |
| 5 | Cater to complex systems | Keep context across services, users and old code. | Kept: Reverse Engineering for brownfield, multi-repo work, Units built in dependency order. |
| 6 | Retain what enhances human symbiosis | Keep the human touchpoints that improve decisions. | Kept: an approval gate at every stage. 2.11 trimmed the agents around the gate, not the gate. |
| 7 | Facilitate transition through familiarity | Map new terms to old ones so a team can start in a day. | Kept. The Classic profile is the version 1 ceremony. |
| 8 | Streamline responsibilities | Fewer handoffs between specialist teams. | Kept as Small Mob, Broad Agents: 14 broad agents, not dozens of narrow ones. |
| 9 | Minimize stages, maximize flow | Fewer phase boundaries, shorter feedback loops. | Strained. The full map has 33 stages; most profiles cut a run to 8 to 18. |
| 10 | No hard-wired workflows | The AI proposes how deep to go; the human adjusts. | Kept: 11 profiles plus a composer agent for custom routes. |
Nine of ten survived. The one that strains is the ninth. A method that asks you to minimize stages now ships 33 of them, and AWS’s answer is to let you skip most of them per run instead of having fewer. That works when someone picks the profile on purpose. It fails when a team runs the full map because it is there.
The gates are the method
Strip AI-DLC to its skeleton and what remains is a loop. The AI produces an artifact. A human checks it. The next step uses the checked artifact as its input. The whitepaper calls each human check a loss function: it catches a wrong decision where reversing it is cheap, before it multiplies through everything downstream.
That framing is right, and it hides the method’s weakest point. The gate is only as good as the person standing at it, and the AI produces artifacts faster than a person can read them with care. What I saw break, in order of frequency:
How gates fail in practice
- The artifact looks complete and says nothing.A well-formatted requirements document reads like a real one. A PM in the rollout compared it to a phishing email from your bank: the familiar format switches off your skepticism.
- The reviewer is tired.After an hour of reading generated documents, people approve without reading. Sessions longer than an hour turned gates into rubber stamps.
- The reviewer does not know the domain.Seniors interrogated every claim and took longer. Juniors accepted the first output. The less you know, the more you trust.
- The tenth approval of the day.Trust calibrates on history. The agent was right nine times, so the tenth gets a glance.
The fix is mostly about pace, not tooling. Keep sessions to an hour. Pause between gates; the state file means pausing costs nothing. Have the manager sit in the first few mobs to stop the rush to approve. And adopt one rule for every reviewer: before you approve, say in one sentence what the artifact does and why it is right. If you cannot, you are not done reading. The whole argument, with the countermeasures, is in gates are a loss function.
AI-DLC needs Spec-Driven Development first
Here is my main disagreement with how AI-DLC usually gets introduced. Teams hear about it, get excited by the agents and the phases, and try to jump from autocomplete to a 33-stage lifecycle. It does not work, and the reason is not the tool.
AI-DLC assumes your people already know how to specify. Every gate asks a human to judge a spec: requirements, stories, design, the plan for each Unit. A team that has never practiced writing a spec cannot judge one. So the agent produces plausible artifacts based on its own assumptions, the humans approve them because they look fine, and the code that comes out the other end needs to be fixed by hand. The execution the agent was supposed to carry lands back on the people. That is slower than writing the code yourself.
The model will satisfy any specification you give it, good or bad. Statistically it lands anywhere between the best and the worst version of what you meant. Specifying well is the only lever that moves that distribution, which is why I see Spec-Driven Development as the step before AI-DLC, not its competitor.
Put AI-DLC on the agentic ladder I use with teams, L1 to L5, and it lands on one rung: L4, where the agent plans, builds and delivers behind a gate and the human approves at the gate. The rungs below are where a team learns to write and judge specs. Skip them and the gates turn into rubber stamps.
The path to AI-DLC on the L1 to L5 ladder
- L1
Assisted
Autocomplete inside the Scrum you already run. The developer writes and decides everything.
Faster typing. Same structure.
- L2
Supervised
The agent changes files on request, from a spec written inside the task. A person reviews every diff.
The team learns to write and judge specs.
- L3
Pull request
The agent takes the whole task from the spec and opens the pull request. You verify against the spec.
Specs become the contract, not paperwork.
- L4
Autonomous
The agent plans, decomposes and builds; humans decide at the gates.
This is where AI-DLC starts to pay.
- L5
Full agentic
Bolts measured in hours, and Operation feeding Ideation without a person starting each loop.
Where the whitepaper points. The engine still needs a person to start the next cycle, so treat it as a direction.
Most teams I meet are at L1 or L2 and believe they are near the top, because they already ship faster than last year. How to score your team on each rung, and why the weakest item sets your ceiling, is in the agentic SDLC playbook. The narrower argument, spec habit first and lifecycle second, is in AI-DLC vs Spec-Driven Development.
AI-DLC and Anthropic’s AI-native SDLC playbook answer different questions
Search “Anthropic AI-DLC” or “Claude AI-DLC” and Google shows you Anthropic’s AI-native SDLC playbook. It is not AI-DLC. AWS wrote AI-DLC; Anthropic wrote the playbook. The confusion is understandable, because both start from an intent written in plain words, both chain versioned artifacts from one step to the next, and both put the human at gates instead of at every line.
The difference is what each one hands you.
AWS AI-DLC
- 01A method plus an open-source engine you install (aidlc)
- 02Five phases, 33 stages, 14 agents, 11 profiles
- 03A deterministic engine decides which stage runs next
- 04Runs in seven harnesses, Claude Code among them
- 05You adopt the lifecycle, or a profile of it
Anthropic's AI-native SDLC playbook
- 01A playbook of plays, no engine to install
- 02Six stages: Plan, Design, Build, Test, Deploy, Maintain
- 03Each stage commits a file the next reads: intent.md, spec.md, plan.md, the diff, the PR
- 04Built on Claude Code features: plan mode, CLAUDE.md, skills, hooks as approval gates
- 05You adopt play by play, in dependency order
So they answer different questions. AI-DLC answers “what process does the team run, stage by stage, and who approves what”. The playbook answers “which part of the SDLC we already have do we change next”. A team on Claude Code can use both: run AI-DLC inside Claude Code, and borrow plays like hooks as approval gates or continuous evals in CI where the AI-DLC stages are thin. The setup for the first half is in AI-DLC with Claude Code.
One thing the playbook gets right that AI-DLC leaves to you: it reserves human code review for regulated and critical code, and lets layers of agentic review take the rest. AI-DLC still puts a person at every approval, and the rollout I followed showed what human review costs at agent speed: code review was never redesigned for the volume, and changes piled up waiting for a human.
Do not adopt AI-DLC as a block
AI-DLC is the most complete public framework for building with agents. I would still not tell a team to adopt it.
Adopting it as a block means announcing “we do AI-DLC now”. People go read the paper and watch the talks, and they try to reproduce a method designed by a company with a different scale, a different culture, and a different stack. They study instead of building. And when it does not fit, they blame themselves or the method.
Treat it like a supermarket shelf. Take what solves a problem you actually have: artifacts that persist in the repo, gates between steps, slices measured in hours, the habit of letting the AI ask. Leave the rest. Write down what you took, what you left, and why.
AI-DLC 2 is the proof that this is the right posture. Teams that adopted version 1 built layers on top of it: state files, retrospectives, parallel construction, custom rules. AI-DLC 2 shipped most of that as native features. The homegrown plumbing became obsolete in one release. What survived was the judgment those teams had encoded: their rules against vibe coding, their ritual for shaping an intent, their sense of when not to use the method at all. The argument is in don’t adopt AI-DLC, steal from it.
What happens when a real team runs it
The docs describe the method. Here is what the rollout added.
Throughput goes up from day one and cycle time gets worse first. The agent produces code immediately, so merged changes per developer jump. But nobody redesigned code review for the new volume, so changes pile up waiting for a human, and the time from first commit to deploy goes up before it comes down. That J-curve is the most predictable thing in an AI-DLC rollout, and the most common reason managers kill it too early. More in why AI-DLC makes you slower first.
The context window is a design constraint, not a detail. An Inception on a real repository fills a large part of a one-million-token window. Teams learned to clear the context at every gate, never in the middle of a phase, and to resume from the state file. Quality dropped noticeably once the window passed three quarters full. Brownfield code makes it worse, because the agent has to reverse-engineer what exists before it proposes anything. All of that is in AI-DLC in brownfield.
Product does not need to sit in the whole mob. The agent asks a long list of questions after reverse engineering, and most of them are technical. The pattern that worked: engineers answer the technical ones, and product joins for the business questions. The Mob Elaboration guide has the rest of the ritual.
The rules that held quality up were small and specific. Never edit generated code by hand; go back to the design. Prefix exploratory questions with “Do not update any documents.” Ask for a critique in a fresh context, because the agent defends what it wrote. They are collected in six rules against vibe coding inside AI-DLC.
And the job changes. Squads shrink toward pods of an engineer and a PM. Backend engineers ship front-end work. The engineer still owns the code in production, because when it breaks at night the agent is not the one paged. Competency matrices that reward writing code start rewarding the wrong thing. That is from squad to pod, and the measurement side is after story points.
How to start without wasting a quarter
A first AI-DLC run that teaches you something
Input
A team that already writes specs and wants to try AI-DLC
- REPOMake the repository readable by an agent
A short AGENTS.md or CLAUDE.md with the stack, the patterns, the forbidden libraries, and one example of each. Brownfield code without this produces guesses.
- PICKPick one real feature, not a one-line fix
Something that needs decomposition and decisions from more than one person. Small enough to finish in a week.
- INSTALLInstall the engine in the agent you already use
aidlc config for your harness, then aidlc doctor. The full Claude Code setup is in its own guide.
- RUNRun the Classic profile
Classic is the version 1 ceremony and the gentlest start: Inception and Construction, 18 stages. Feature runs all 33; save it for later. Keep sessions to one hour, clear context at gates, and turn collaborators on if you want the agent mob back.
- MEASURERead throughput next to cycle time
Expect the J-curve. Decide after about four weeks whether you are learning or stuck.
Output
One feature shipped through the method, and an honest list of what to keep, change, or drop.
The concrete setup, with the commands, is in AI-DLC with Claude Code. If your team is not specifying yet, start one step earlier with how to write a spec, or with a lighter kit like claude-sdd-kit for Claude Code or pi-sdd-kit for pi, and come back when writing and judging specs feels normal.
What the independent analyses add
AWS wrote the method, so read the people who did not. Augment Code’s guide to AIDLC maps the competing names for the same shift (AWS’s AI-DLC, Forrester’s agentic software development, Cycode’s ADLC). Wiz reads it as a security problem: the speed is the asset and the risk at once, with roughly a fifth of AI-suggested packages pointing to dependencies that do not exist. Mission Cloud adds the idea of a living spec, kept in sync with the code by an agent.
Augment also names the real choice behind all of this: human in the loop, where a person approves each step, against human on the loop, where a person watches and steps in. AI-DLC as AWS ships it is firmly in the loop. Release 2.11.0 moved a little toward on the loop, with lighter defaults and Continue automatically in Construction, but a gate still needs a person. The analyses converge on the point the rollout taught me: the AI is not the hard part. The people at the gates are.
FAQ
What does AI-DLC stand for?
AI-Driven Development Life Cycle. It is a software development method published by AWS in July 2025, in which an AI agent plans the work and produces the artifacts while humans approve or reject them at gates. The open-source implementation lives at github.com/awslabs/aidlc-workflows.
What are the phases of AI-DLC?
The original method has three: Inception, Construction, and Operations. Most articles still teach those.
AI-DLC 2, the version AWS ships today, has five: Initialization, Ideation, Inception, Construction, and Operation, with 33 stages between them. Release 2.11.0, checked October 13, 2026.
Is AI-DLC from Anthropic?
No. AI-DLC comes from AWS. Anthropic published a different document, the AI-native SDLC playbook: six stages of plays built on Claude Code features, with no engine to install. AI-DLC runs inside Claude Code, which is probably where the mix-up starts.
Is AIDLC the same as AWS AI-DLC?
Usually, yes. AWS writes AI-DLC in prose and aidlc in the repository name and the command. Some vendors use AIDLC more loosely for any AI-driven way of running software delivery, so check whether a page means AWS's method or a general idea.
Is AI-DLC only for AWS?
No. The method is provider-independent, and AI-DLC 2 runs inside Claude Code, Kiro CLI, Kiro IDE, Codex CLI, Cursor, opencode, and GitHub Copilot with the same engine.
AWS fingerprints remain: one of the 14 agents is an AWS platform specialist, and optional AWS MCP servers ship with it. On another cloud you ignore them or replace them.
Has anyone implemented AI-DLC at work, and how did it go?
I followed one rollout in a large engineering organization, from pilot squads to a training program. Throughput went up first and cycle time got worse before it got better, because review was not redesigned for the volume.
What held quality up was pace and small rules: one-hour sessions, clearing context at gates, never editing generated code by hand. The details are in the sections above.
Does AI-DLC replace Scrum or Agile?
It replaces the rituals, not the values. Sprints become bolts measured in hours, planning becomes Mob Elaboration, and the daily shrinks to a few minutes. Kanban fits better than sprints.
Teams that tried to keep two-week sprints around an agent found the agent waiting on the calendar.
What happens to Scrum Masters in AI-DLC?
The method does not name the role. The rituals a Scrum Master runs get shorter or disappear, and a new one appears: someone has to facilitate Mob Elaboration, keep sessions to an hour, and stop the room from approving what nobody read. AWS ships a facilitator guide for the person who runs a team through its first workflows.
How does AppSec fit into AI-DLC?
Inside the method, a DevSecOps agent and a compliance agent take part in the stages, there is a security-patch profile for CVEs, and the enterprise profile holds the strictest guards. Outside it, Wiz's point stands: agents ship faster than a security team reviews, so checks that run on every change matter more than a review queue.
What is the difference between AI-DLC and Spec-Driven Development?
Spec-Driven Development is a practice: write the spec, let the agent build from it, verify against it. AI-DLC is a full lifecycle that assumes your team already does that, and adds phases, gates, agents, and team rituals around it. SDD is the prerequisite, not the alternative.
What is a Bolt in AI-DLC?
A Bolt is the delivery slice that replaces the sprint: work measured in hours or days instead of weeks. In AI-DLC 2 it is a planned slice over one or more dependent Units, and the build order follows the dependency graph between Units.
Do I need Kiro to use AI-DLC?
No. Kiro was the first home for AI-DLC's steering files, but AI-DLC 2 treats seven harnesses as first-class, including Claude Code, Cursor, and Codex.
Is AI-DLC free?
Yes. The workflows are open source under the MIT-0 license. You pay for the model your agent uses, and an AI-DLC run reads and writes a lot of context, so watch the token bill on the first runs.
When should I not use AI-DLC?
When you already know exactly what to change. A one-line fix, a typo, a config bump. The method pays when the work needs decomposition and decisions from more than one person. Below that, use a lighter profile like Bugfix or Express, or just write the code.
Where to go next
AI-DLC is the clearest public answer so far to the question every engineering leader is asking: how do we build software with agents without losing control of what we ship. The answer is not the agents. It is the gates, the artifacts, and the people who can judge them. Get your team specifying first, take from the method what fits, and measure honestly when the curve dips.
For engineering teams
Rolling AI-DLC out to a team? I help engineering orgs score each project on the L1 to L5 ladder, pick the ceiling its cost of error allows, and climb one item at a time.
Talk to me