AI DeliveryPreview Learning Center

The lifecycle

The AI software delivery lifecycle, step by step

Seven stages and twenty-one steps. Play it, step through it with the arrow keys, switch to the before-and-after lanes or to the gates alone, open it full screen, or download the SVG. Every step's text cites the page it was read on.

the AI actsa person actsa gate: a person or the repository decides

Read it

The same twenty-one steps, in text, with their sources

Green is the agent, coral a person, amber a gate where a person or a rule the repository enforces decides. The numbers in brackets are the sources, listed on Method and sources.

Stage 1 of 7

Plan: Intent becomes a spec both people and agents can read

  1. 1.1

    Intent arrives Person

    A product owner writes what should change and why, in a spec, not a chat message. The spec is the first artifact of the lifecycle and the one everything later is checked against.

  2. 1.2

    The agent drafts the plan AI

    An agent reads the spec and the repository, proposes a technical plan and a task list, and flags what the spec leaves open. Spec Kit's phases name exactly this hand-off: Spec, then Plan, then Tasks [6].

  3. 1.3

    A person owns the spec Gate

    Nothing moves until a named person accepts the spec and the plan. The agent can propose; it cannot decide what the product is.

Open the Plan stage: before and after, gate, risks, tools and sources →

Stage 2 of 7

Architect: Cloud design reviewed against principles, as code, before anything is built

  1. 2.1

    The agent proposes a design AI

    From the spec, an agent drafts the architecture: services, data flows, trust boundaries, the cloud resources as code, and a first threat model of where untrusted input meets a tool.

  2. 2.2

    Principles review it AI

    A second pass checks the design against written principles, the six of the AWS Generative AI Lens among them, and against the organization's own decision records [7].

  3. 2.3

    An architect decides Gate

    A person signs the decision record. Controlled autonomy is the first of the Lens's principles for a reason: the boundaries of what the system may do are set here, by people [7].

Open the Architect stage: before and after, gate, risks, tools and sources →

Stage 3 of 7

Build: Agents write under rules the repository enforces, not rules it hopes for

  1. 3.1

    The agent takes a task AI

    From the task list, an agent opens a branch, reads the brief in the repository and starts to write. Everything it does runs under the hooks and permissions configured for that repository [9].

  2. 3.2

    Hooks run on every edit Gate

    After each edit, a PostToolUse hook formats the file and runs the fast tests; before each shell command, a PreToolUse hook can refuse it with exit code 2. The rule holds whether the agent remembers it or not [9].

  3. 3.3

    A pull request opens AI

    The agent opens a pull request with the tests that prove the change. From here on the repository, not the author, decides what merges; the full real example is the AI SDLC on GitHub page in the test center [10].

Open the Build stage: before and after, gate, risks, tools and sources →

Stage 4 of 7

Test: Every incident earns a test, and every AI-written test carries its provenance

  1. 4.1

    Tests arrive with the change AI

    The pull request carries unit, property and contract tests written against the spec. A subagent that may only write tests grades them by mutation score, so a test that cannot fail is caught [10].

  2. 4.2

    Checks run in parallel Gate

    Lint, unit, property, contract, the eval suite and the Test Passport check all start on the pull_request event; each is a required status check, so none can be skipped [10].

  3. 4.3

    The pass rate decides Gate

    For the AI parts, the gate is a pass rate with a confidence bound over repeated runs, not a single green [13]. The number is in the repository, where a person set it.

Open the Test stage: before and after, gate, risks, tools and sources →

Stage 5 of 7

Release: Continuous delivery with provenance, canaries and a person at the production gate

  1. 5.1

    Build once, attest AI

    Main is built once; the artifact is signed and its provenance recorded, so what reaches production is verifiably what was tested [5].

  2. 5.2

    Canary and verify AI

    The build goes to staging through short-lived cloud credentials, then to a canary slice of production, while an agent compares its signals with the baseline and drafts the release notes [10].

  3. 5.3

    A person opens production Gate

    The production environment requires a reviewer. The agent has prepared everything it can; the approval is a human act, logged with a name [10].

Open the Release stage: before and after, gate, risks, tools and sources →

Stage 6 of 7

Operate: Agents on call: anomaly detection, enriched alerts, drafted postmortems, people where it matters

  1. 6.1

    Signals, not thresholds AI

    Agents collect signals and feed a model that flags deviations from regular behavior, then group and enrich what fires, so the person on call sees one enriched incident, not forty alerts [3].

  2. 6.2

    Investigate and propose AI

    Using observability data, topology and dependencies, an agent forms hypotheses and proposes mitigation steps; for some low-risk cases it mitigates on its own [3].

  3. 6.3

    A person holds the risky ones Gate

    For higher-risk services a person decides, with the agent's reasoning in front of them: Google's principles require agents to explain why and how they acted and what they rejected, favoring transparency over black-box automation [3].

Open the Operate stage: before and after, gate, risks, tools and sources →

Stage 7 of 7

Govern: Policy as code, evidence as a by-product, a framework written for AI software

  1. 7.1

    Policy becomes code Person

    Security writes the rules as policy code and hooks: what an agent may never run, which files it may never touch, which egress is allowed. The rules are reviewed like any code change.

  2. 7.2

    The pipeline produces the evidence AI

    Each run leaves attestations, logs and approvals behind it. An agent assembles them against the controls of a framework such as the SSDF, so the audit reads the pipeline rather than interviewing the team [4].

  3. 7.3

    People own the exceptions Gate

    An exception to a policy is a pull request with a named approver and an expiry. The loop closes: what governance learns here becomes the next stance in Plan, and the lifecycle starts again.

Open the Govern stage: before and after, gate, risks, tools and sources →