Phase 04

Launch Release Assurance & CI/CD

Release assurance on the integrated build, intelligent CI/CD configuration, deployment automation, and release validation. Reduce friction from commit to production.

A rocket lifting off from a delivery pipeline of passed quality gates

What is the Launch Phase?

The Launch phase focuses on everything between writing code and getting it to production. This is where AI helps eliminate the tedious, error-prone work of testing and deployment.

Traditional testing is often the first thing cut when deadlines loom. In AIDLC the tests already exist by the time work gets here: every ticket left Develop with its unit, integration and contract tests, written from its acceptance criteria before the code. Launch is assurance, not authorship: it runs that suite against the integrated release and adds only the checks that cannot exist before there is a release. CI/CD configuration - often a copy-paste mess of YAML - becomes something AI can generate and maintain.

Increasingly this is agentic: an agent can hunt for gaps in the suite, open the pull request, watch the pipeline, and propose a fix when a check fails - with you approving each step. The guardrails still belong to humans, but the busywork between commit and production keeps shrinking.

In the Launch phase, AI helps you:

  • Run the full suite against the integrated release candidate and look for gaps as an independent critic
  • Create and optimize CI/CD pipeline configurations
  • Write deployment scripts and infrastructure code
  • Validate releases with automated smoke tests
  • Create rollback procedures and runbooks

Quick Reference

AI Role

QA Engineer / DevOps

Key Output

Verified release candidate, smoke and health checks, rehearsed rollback, pipelines

Tools

Claude Code, GitHub Actions, Codex

Human Owner

Release owner, with the QA and platform leads

Exit Gate

Release validated, rollback path proven


Inputs and Outputs

Launch carries merged code the last distance to users. It takes in work that review has already approved and hands over proof that the release is safe to run and safe to undo.

What it receives

  • Merged pull requests from Develop, approved at their risk tier, each with the unit, integration and contract tests its acceptance criteria call for.
  • The ticket contracts those pull requests implement, including the risk tier, feature flag, and rollback plan for each.
  • The existing pipeline, test suites, environments, and infrastructure definitions.
  • The repo instruction file and the hard rules that govern what an agent may do in the pipeline.

What it hands off

  • Assurance results for the integrated build: the full suite green, a mutation re-check on the critical modules, and any gap written up as a failing test sent back to Develop.
  • Pipeline changes: build, test, and deploy definitions, reviewed by a human before they take effect.
  • A Release Plan with a rollback path, either a feature flag or a tested revert.
  • Release validation: smoke tests, health checks, and a record of what was verified in production.

A release is not done until it can be undone

Launch is where an unreviewed assumption becomes an outage. Every release leaves with its rollback path written down and exercised, and every agent in the pipeline works under the hard rules on Agents in the Pipeline: it opens pull requests rather than pushing to protected branches, and it stops and asks a human after two repair attempts.

Key Activities

Release Assurance

AI runs the full suite against the integrated release candidate, re-checks mutation scores on the critical modules, and acts as an independent critic looking for criteria or module boundaries no test covers. A gap becomes a failing test that goes back to Develop.

Example Prompt: "Run the full suite against this release candidate and re-check mutation on the payment module. For each gap, write one test. If it fails, file it for Develop instead of fixing the code. Do not change existing tests."

CI/CD Configuration

AI creates and optimizes CI/CD pipelines for GitHub Actions, GitLab CI, or your platform of choice.

Example Prompt: "Create a GitHub Actions workflow that runs tests, builds the app, and deploys to staging on PR merge."

Deployment Scripts

AI generates deployment scripts, Dockerfiles, Kubernetes manifests, and infrastructure-as-code configurations.

Example Prompt: "Create a Dockerfile for this Node.js app with multi-stage build for optimal image size."

Release Validation

AI creates smoke tests, health checks, and validation scripts to ensure releases are working correctly in production.

Example Prompt: "Create a post-deployment smoke test script that validates all critical API endpoints are responding."

Assurance, Not Authorship

Unit, integration and contract tests are written test-first in Develop, from the acceptance criteria and the contracts Ideate produced. Launch runs that suite against the integrated release and writes a new test only when it finds a gap. A gap test that fails is a defect, and it goes back to Develop as the feedback. One that passes means the code was right but the suite was thin: the test stays, and the Develop gate that should have required it is tightened. The whole strategy, phase by phase, is on Testing Strategy.

Full suite

Every existing test, run against the integrated release candidate

Gap check

An independent critic and a mutation re-check look for what the suite misses

Smoke

Post-deploy checks that the release works in production

Coverage shows which lines ran, not whether the tests would notice a bug. Generated tests can reach high coverage while asserting almost nothing. Score the modules that matter with mutation testing, which changes the code and checks that a test fails, and generate tests from the acceptance criteria rather than from the implementation. See tests first, mutation scored and mutation score in the glossary.

Data and Infrastructure Changes

A bad code change can be reverted. A bad schema change or infrastructure change often cannot, so these get extra care when an agent wrote them. Treat them as the highest risk tier described under risk-tiered review, with the rollback path decided before the change ships.

Schema migrations: expand, then contract

Use the parallel change pattern. Expand: add the new column or table alongside the old one, and let the application write to both. Backfill and verify. Switch reads to the new structure. Contract: remove the old structure in a later release, once nothing depends on it. Each step is small and can be reverted on its own, which is what makes the migration safe to ship while code is also changing.

Reversible and irreversible migrations

Label every migration. A reversible one, such as adding a nullable column, can be undone with a down step. An irreversible one, such as dropping a column or rewriting data in place, cannot, so it needs a verified backup, a rehearsal on production-like data, and an explicit human decision. Migrations are reviewed at the highest risk tier, and an agent never merges one alone.

Infrastructure as code

Agents can draft infrastructure as code, but a human reads the plan output, the exact list of resources to be created, changed, or destroyed, before anything is applied. Agents never hold production apply credentials. Apply runs from the pipeline under a human approval, with credentials the agent cannot read.

Progressive delivery as the rollback path

Ship agent-authored changes behind a feature flag, then widen exposure by percentage or through a canary release. Define automated rollback triggers in advance, such as an error-rate or latency threshold, so the flag turns off without waiting for a person to notice. If a change cannot be flagged, its rollback path is a tested revert.

Stale flags are debt

Every flag needs an owner and a removal date when it is created. A flag that has been fully on for weeks is dead branching in the code, and a reader, human or agent, cannot tell which path is real. Track flags in the ticket contract, and make removing the flag a ticket of its own.

Example Workflow

1

Collect the Merged Work

List the merged pull requests in the release, with their tickets, risk tiers, flags, and rollback plans. An agent can draft the release notes from them.

2

Verify the Integrated Build

Run the full suite against the release candidate and re-check mutation on the touched critical modules. Any gap becomes a test: a failing one goes back to Develop as a defect, a passing one is kept and tightens the Develop gate that missed it.

3

Plan Data and Infrastructure Steps

Order the expand steps for any schema change, and have a human read the infrastructure plan output before anything is applied.

4

Write the Release Plan

State what ships, behind which flag, to whom first, which signals decide to widen or roll back, and who can pull the trigger.

5

Release Progressively

Turn the flag on for a small share of traffic or a canary. Watch the signals named in the plan. Automated triggers roll back on a breach.

6

Validate the Release

Run smoke tests and health checks against production, and record the result with the release.

Move to Curate

Once the release is validated and the flag is fully on, the running system becomes the input to the Curate phase. Remove the flag when it has done its job.

Launch workflow from Collect Merged Work through Verify Integrated Build to Move to Curate, with a Gap test fails loop back to Develop.

Who Owns It

A named release owner is accountable for each release. The QA lead owns the quality gates, including the mutation threshold. The platform or DevOps lead owns the pipeline and the credentials it uses. Agents work inside those boundaries and never widen them.

What the AI drafts

  • Gap tests where assurance finds a hole, the mutation re-check report, and smoke checks for production.
  • CI/CD configuration, Dockerfiles, and infrastructure-as-code drafts.
  • Release notes, smoke-test scripts, and rollback procedures.
  • A first diagnosis when a pipeline check fails, and a proposed fix as a pull request.

What humans decide

  • Whether the release is ready, and whether to widen, hold, or roll back.
  • Approval of every pipeline and infrastructure change, and every infrastructure apply.
  • Whether a failing test points at a bug or at a test to fix. Agents do not weaken or skip tests to turn a build green.
  • Any migration that cannot be reversed.

Entry and Exit Criteria

Entry criteria

Start the phase when all of these are true.

  • All pull requests in scope are merged and were reviewed at their risk tier.
  • Each ticket has its flag, risk tier, and rollback plan filled in.
  • The pipeline runs under its own agent identity with least-privilege permissions.

Exit criteria

Leave the phase only when all of these are true.

  • The full suite is green on the integrated release candidate, and the mutation re-check finds no new survivors on the touched critical modules.
  • Pipeline and infrastructure changes were read by a human before they took effect.
  • The Release Plan names a rollback path, and it has been exercised or rehearsed.
  • Release validation passed in production and the result is recorded.
  • Any flag that finished its rollout has a removal ticket.

Best Practices

Gate on mutation score, not coverage

Coverage can be satisfied by tests that assert nothing. A mutation score on critical modules shows whether the tests would catch a real change.

Write the rollback path before the release

Decide how a change will be undone while no one is under pressure. A flag or a tested revert is the answer for every agent-authored change.

Keep production credentials away from agents

Agents propose, humans approve, and the pipeline applies with credentials an agent cannot read. Give each workflow its own identity and budget.

Do not let an agent edit a test to make a build pass

Deleting an assertion or adding a skip turns a failing check green and hides the bug. A weakened test needs a label and a human.

Anti-Patterns

The named patterns are catalogued on Twelve Ways AI Adoption Fails. These are the ones that bite in Launch.

Coverage as the Test Gate

A high coverage number, a green build, and an incident the tests never had a chance of catching. Gate on mutation score for the modules that matter.

Personal Tokens in CI

The pipeline agent acts as the developer who set it up. Give it a service identity so its actions are attributable and survive staff changes.

Model Upgrade Without Evals

A review agent or planning skill changes behavior when the underlying model does, and nobody notices until a defect class starts escaping.

What to Measure

Launch is where most of the raw delivery data originates. Pick from Measuring Impact.

Deployment frequency

How often the team actually ships, independent of how much code was written. Flat frequency with rising output means a queue.

Change failure rate

The share of deploys that need a hotfix, rollback, or incident. It should hold flat or fall as agents take on more work.

Mutation score

A direct read on test quality for the modules that matter, so a coverage figure cannot hide untested logic.

Cycle time, ticket to production

The end-to-end view. Launch delays, such as slow pipelines and manual approvals, show up as a long tail here.

Go Deeper

Launch prompts

Prompts for release assurance, pipelines, deployment scripts, and validation.

Read more

Agent hard rules

Seven enforceable rules for any agent that runs unattended in a pipeline.

Read more

Tests first, mutation scored

Why coverage misleads and how mutation testing fixes the gate.

Read more

Agents in the Pipeline

Identity, permissions, sandbox, and budget for agents in CI.

Read more

A worked example

One feature carried through all five phases, including its release plan.

Read more

Frequently Asked Questions

By the time work reaches Launch, its unit, integration and contract tests already exist: Develop writes them test-first from the acceptance criteria. Launch is assurance. AI runs the full suite against the integrated release, re-checks mutation scores, looks for gaps as an independent critic, and writes the smoke tests and health checks that validate the release in production. A gap that exposes a defect becomes a failing test that goes back to Develop.

Yes. AI can generate CI/CD configurations for platforms like GitHub Actions, GitLab CI, and Jenkins. It understands your project structure and suggests appropriate build, test, and deployment steps.

Agent-authored changes arrive faster and in greater volume, so some will be wrong in ways review did not catch. A rollback path, either a feature flag that turns the change off or a tested revert, turns a production incident into a quick reversal instead of an emergency fix. The Release Plan states the path before the release ships, not after something breaks.