# How AI-DLC, BMAD, Spec Kit and Scrum Fit One Lifecycle

Lay every method on the same four phases and two things appear: they mostly agree, and they all leave the same decisions open.

7 min read · Intermediate · Lesson 6 of 7 in Methods decoded · Updated 2026-10-03 · By Akash Das

Canonical: https://akash-coded.github.io/aws-bedrock-agentcore-strands/learn/one-lifecycle-for-every-method/

> **In short.** Every building method fits onto the agentic PDLC's four phases, and most of their stages land in P1
> and P2. Laying them side by side shows the same gap in all of them: none sets an acceptance bar per
> slice from what a mistake costs, and none enforces authority per action. Almost none says how to
> watch a model in production and report its value beside its cost.

![AI-DLC, BMAD, Kiro, Spec Kit, Scrum and Shape Up placed on the four phases](https://akash-coded.github.io/aws-bedrock-agentcore-strands/assets/learn/map-one-lifecycle-for-every-method.light.webp)

**In this lesson** you'll learn:

- where each well-known method's stages sit on the four phases;
- the decisions every one of them leaves open, and who should own each;
- how to combine a building method with the lifecycle without running two processes.

## Sound familiar?

- The team runs Scrum, the architects want Spec Kit, and a vendor is pitching AI-DLC, and the argument is about which one wins.
- Every method you evaluate has a planning phase and a building phase, and none has a clear answer to "is it good enough to ship?"
- After launch, nobody's method says who watches the agent, or who tells the sponsor what it cost.

The map settles the first by showing that the methods mostly agree. It exposes the second and third
as gaps that a lifecycle has to fill, whichever method you choose.

## Where does each method sit?

![Four methods on one lifecycle: SDD, BMAD, AI-DLC and AIDD, filled where each speaks to a phase and dashed where it is silent](https://akash-coded.github.io/aws-bedrock-agentcore-strands/assets/learn/frameworks-methods.light.webp)

| Method | P0 · Frame | P1 · Design & Spec | P2 · Build & Prove | P3 · Run & Learn |
| --- | --- | --- | --- | --- |
| **AWS AI-DLC** | Inception: the business intent | Inception: Mob Elaboration, units of work | Construction: Mob Construction, in bolts | Operations: infrastructure and deployment |
| **AIDDLC** | Foundation, Discovery & Intelligence | Architecture & Design, Specification | Build, Validation | Deploy & Learn |
| **Kiro** | none | `requirements.md`, `design.md` | `tasks.md`, task by task | none |
| **GitHub Spec Kit** | none | Constitution, specify, plan, tasks | Implement | none |
| **BMAD Method** | The Analyst's brief | The PRD, the UX pair, the architecture spine | A spec, its stories, Build per story, the retrospective | Extended BMAD: learn and adjust, into the next brief |
| **Scrum** | Backlog refinement | Sprint planning | Sprints (here, bolts) and the review | The retrospective |
| **Shape Up** | Shaping and the betting table | The shaped pitch | The six-week cycle | none |
| **Stage-gate** | Discovery and scoping | The business case | Development, testing and validation | Launch |

## How to combine them, step by step

### Step 1 · Map your method's stages onto the four phases

Write your method's stages against P0 to P3, as in the table. Most land in P1 and P2, because most
methods are about how to build. That is not a flaw. It is what they are for.

### Step 2 · Find the empty cells and the thin ones

Look for the phases your method leaves empty or covers only in part. For almost every building method
the same things are missing, because they are questions about **the model inside the product**, not
about how the product is built:

| Open decision | Phase | Who should own it |
| --- | --- | --- |
| Whether the job needs a model at all, and what it is worth net of running and checking | P0 | Product manager |
| The acceptance bar for each slice, from what a mistake costs | P1 | Product manager and QA |
| Authority per action, with every limit enforced in a tool's signature | P1 | Solution architect |
| A harness that blocks a merge when a slice falls below its bar, and a shadow run | P2 | Engineering and QA |
| A drift watch, and the saving reported beside the spend | P3 | QA, DevOps and the sponsor |

### Step 3 · Give each gap an owner inside your existing ceremonies

Do not add a second process. Put the bar and the authority budget into the planning ceremony you
already hold; make the harness a required check in the pipeline you already run; add the drift chart
and the two numbers to the review you already give the sponsor.

### Step 4 · Keep one spec, whatever the method

Every method above produces some form of specification. Keep one, in the repository, as the artefact
agents build from, whether your tool calls it `requirements.md`, a spec, a PRD or a pitch. The eight
fields of the [agentic spec](https://akash-coded.github.io/aws-bedrock-agentcore-strands/learn/p1-design-and-spec/#step-2--write-the-eight-field-spec) are what it
must contain.

### Step 5 · Hold the phase exits, not the method's ceremonies

What makes it work is not the rituals but the exits: each phase ends on evidence, and P1 → P2 is
the [hard gate](https://akash-coded.github.io/aws-bedrock-agentcore-strands/learn/the-hard-gate/). A team can run Scrum, Spec Kit and AI-DLC's mob sessions and
still skip every exit; a team that holds the exits can run any of them.

## Where you'll use it

- **When choosing a method**: map the candidates first, and choose on what fits your team, since the
  gaps are the same.
- **When two teams run different methods**: the four phases are the shared vocabulary for hand-offs.
- **When auditing a programme**: an empty P3 column is the most common and most expensive gap.

## Why it matters

Method arguments are expensive and mostly beside the point. The failures that cancel agentic projects
(escalating cost, unclear value, weak risk controls) live in the cells that every building method
leaves empty. Mapping them makes that visible in one table.

![A worker holds up two recipe cards, one marked Scrum and one marked Spec Kit, and looks from one to the other. Behind its back a saucepan boils over on the stove with nobody watching it.](https://akash-coded.github.io/aws-bedrock-agentcore-strands/assets/learn/sketch-recipes-and-the-unwatched-pot.light.webp)

*The argument is about which method wins. No method says who watches the agent once it is live.*

## Try it

A team runs Scrum with Spec Kit inside its sprints. Its product is an agent that drafts and sends
customer replies. **Using the map, which phase has no owner at all?**

<details><summary>Show the answer</summary>

**P3, Run & Learn.** Spec Kit stops at *implement*, and Scrum's retrospective looks at the team, not at
the agent's behaviour in production. Nobody is watching the mix of the agent's replies for drift, nobody
has rehearsed switching it back to drafting-only, and nobody reports what it saved beside what it
costs. The fix is an owner for each inside existing ceremonies, not a new method.

</details>

## Key takeaways

1. **Every method fits the four phases**, and most of their stages land in P1 and P2.
2. They share **the same gaps**: the bar per slice, authority per action, proof before launch, and the operating loop.
3. Combine without a second process: **own the gaps inside your existing ceremonies**, keep one spec, and hold the phase exits.

## FAQ

### Can I use AI-DLC with Scrum?

Yes. The ceremonies can stay; the planning unit shrinks from the sprint to the bolt, and Inception's
Mob Elaboration can replace or feed sprint planning. The phase exits, especially the hard gate between
design and build, apply whichever you keep.

### What is the best AI development methodology?

There is no best one in general. The methods mostly agree on how to build and differ in ceremony and
tooling; choose the one that fits your team and tools. What decides success is whether the decisions
they all leave open (the bar, the authority budget, the operating loop) have owners.

### Is Shape Up compatible with AI-driven development?

Yes. Shaping and the betting table are a strong P0; the shaped pitch is a P1 input; and the six-week
cycle can be run as a sequence of bolts. Shape Up's appetite, how much time an idea deserves, pairs
naturally with the value line.

### What replaces the sprint when AI writes the code?

The bolt: a slice of hours or days, carrying one unknown, integrated the same day. The term comes from
AWS's AI-DLC; the rule of one unknown per bolt is this manual's.

## Apply it in your role

| If you are… | Do this | The AI-augmented shortcut |
| --- | --- | --- |
| **A forward-deployed engineer** | Map the customer's method onto P0 to P3 in the first meeting, then fill the three gaps every method shares: the bar, authority in code, production evidence. | Ask a model to place each stage of the customer's process on the four phases. |
| **A product manager or FDPM** | Run mixed-method teams on one lifecycle: the phases and hand-offs are shared, the method inside each team is theirs. | Have a model generate the hand-off checklist per phase for each method in use. |
| **A GenAI or agentic AI engineer** | Whatever the method, the harness, the caps and the per-call log are the same code. Build them once, as a library. | Ask a coding agent to extract them into a shared package with its own tests. |

**Across the enterprise.** Let teams choose methods and standardise the hand-offs: four checklists, one
evidence pack index and one portfolio report, whatever each team calls its stages.

**The ten-minute workflow.** One map of every method your organisation uses:

```text
Our teams use <methods>. Map each method's stages onto P0 Frame, P1 Design & Spec, P2 Build & Prove
and P3 Run & Learn in one table. Then list what each method leaves unsaid on three points: an
acceptance bar per slice, authority enforced per action, and production evidence of value beside cost.
```

## Sources and credits

| Idea | Origin | Source |
| --- | --- | --- |
| AI-DLC's phases, rituals and bolts | **Borrowed** | Raja SP (2025). [AI-Driven Development Life Cycle](https://aws.amazon.com/blogs/devops/ai-driven-development-life-cycle). AWS |
| AIDDLC's seven phases | **Borrowed** | [AIDDLC: AI-Driven Development Lifecycle Standard](https://www.aiddlc.ai/) |
| Kiro's specs and Spec Kit's workflow | **Borrowed** | [Kiro specs](https://kiro.dev/docs/specs/) · GitHub (2025). [Spec Kit](https://github.com/github/spec-kit) |
| The BMAD Method | **Borrowed** | BMad Code. [BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) |
| Scrum's events | **Borrowed** | Schwaber, K. & Sutherland, J. (2020). [The Scrum Guide](https://scrumguides.org/) |
| Shaping, betting and six-week cycles | **Borrowed** | Singer, R. (2019). [*Shape Up*](https://basecamp.com/shapeup). Basecamp |
| Stage-gate | **Borrowed** | Cooper, R. G. (1990). Stage-gate systems. *Business Horizons* 33(3) |
| The mapping, and the gaps it shows | **Original**: this tutorial | [The Agentic PDLC](https://github.com/akash-coded/aws-bedrock-agentcore-strands/wiki/The-Agentic-PDLC#how-the-named-methods-sit-on-the-spine) |
