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.

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
QA Engineer / DevOps
Verified release candidate, smoke and health checks, rehearsed rollback, pipelines
Claude Code, GitHub Actions, Codex
Release owner, with the QA and platform leads
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.
CI/CD Configuration
AI creates and optimizes CI/CD pipelines for GitHub Actions, GitLab CI, or your platform of choice.
Deployment Scripts
AI generates deployment scripts, Dockerfiles, Kubernetes manifests, and infrastructure-as-code configurations.
Release Validation
AI creates smoke tests, health checks, and validation scripts to ensure releases are working correctly in production.
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.
Every existing test, run against the integrated release candidate
An independent critic and a mutation re-check look for what the suite misses
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
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.
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.
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.
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.
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.
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.

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 moreAgent hard rules
Seven enforceable rules for any agent that runs unattended in a pipeline.
Read moreTests first, mutation scored
Why coverage misleads and how mutation testing fixes the gate.
Read moreFrequently 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.