---
title: "AI SDLC framework: phases, roles and guardrails"
description: "A practical AI SDLC framework: plan, build, review, test, deploy and operate. Human vs agent roles, a checklist, and how Automo Build runs each phase."
canonical: https://automo.build/learn/ai-sdlc-framework
last-updated: 2026-11-19
---
# AI SDLC framework: phases, roles and guardrails

A working model for running the software lifecycle with AI agents: who does which phase, where humans stay in the loop, and which guardrails keep speed from becoming sprawl.

An AI SDLC framework is a practical operating model for running the software development lifecycle with AI agents across plan and spec, build, review with guardrails, test, deploy, and operate. Humans set intent and approve consequential changes; agents do the production work under those rules. It is the how of an AI SDLC, not only the definition.

## What is an AI SDLC framework?

If you need the definition of the lifecycle itself, start with [What is an AI SDLC](/learn/what-is-an-ai-sdlc). This page is the operating model you run on top of that definition: phases, human versus agent roles, and the guardrails that make the loop safe at AI speed. When you are choosing products for each phase, use the companion [AI SDLC tools guide](/learn/ai-sdlc-tools).

A classic SDLC assumes people write the work and other people check it. An AI SDLC framework assumes agents write most of the work and people govern classes of change. The phases still exist. What changes is the unit of work (a prompt and a plan instead of a ticket pile), the control point (policy instead of reading every line), and the evidence (an audit trail from prompt to production instead of tribal memory).

Treat the framework as a coverage checklist, not a mandated org chart. Vendors name stages differently. If a phase has no owner, no gate, and no artifact, you do not have that phase. You have a slide.

## Six phases of an AI SDLC framework

Plan and spec, build, review and guardrails, test and QA, deploy, operate and monitor. The first is human-led. The middle four are where agents do the volume under controls. The last keeps the system honest after it ships.

1. **Plan and spec** Work enters as testable intent: the problem, users, constraints, and what done looks like. Agents turn that into a reviewable plan (what will change, which areas it touches, the risks). Humans correct course here, where corrections are cheap.
2. **Build** Builder agents implement the plan in real code on branches. Application logic, schema, integrations. Every change is a versioned, reviewable diff, not an opaque edit to a running system.
3. **Review and guardrails** Policies classify each change by the business area it touches and its risk. Routine changes proceed. Consequential ones wait for recorded human approval. Protected zones refuse casual modification. Reviewer agents (CTO, Security, Doctor) plus a human product owner triage what needs a person.
4. **Test and QA** Automated verification runs on every change, not as a phase at the end: unit and integration checks plus browser-level replays of the flows that matter. Failing gates stop the line.
5. **Deploy** Releases move through smoke gates before publish and checks after, with rollback as a first-class operation. Deployment is a controlled stage, not a button beside the lifecycle.
6. **Operate and monitor** The live system is watched. Application health, DNS, CDN, dependencies. Degradations are diagnosed to root cause and fed back as new described work, closing the cycle.

## What changes versus a classic SDLC

Same job, different machinery. Use this table when someone says AI SDLC is just CI/CD with a chatbot.

| Phase | Classic SDLC | AI SDLC framework |
| --- | --- | --- |
| Plan and spec | Tickets written for developers | Plain-language intent, testable by anyone, agent-drafted plan |
| Build | Developers write code by hand | Builder agents produce versioned diffs at high volume |
| Review | Humans read every line | Policies triage; humans review what policy flags |
| Test | QA near the end | Automated gates on every change, including browser-level |
| Deploy | Release windows and change boards | Gated publish, production checks, rollback ready |
| Operate | On-call humans triage dashboards | Agent diagnosis of root cause, humans approve fixes |

## Humans versus agents

Agents do production work. Humans own outcomes. If you reverse that, you have an unattended system, not a framework.

| Responsibility | Humans | Agents |
| --- | --- | --- |
| Direction | Set intent, constraints, definition of done | Turn intent into a reviewable plan |
| Implementation | Architecture calls and exceptions | Write and edit the code |
| Review | Approve consequential and protected-zone changes | Classify risk, apply policy, draft review notes |
| Quality | Decide which flows must never break | Author and run tests on every change |
| Security | Accept residual risk, own the incident | Scan, probe, confirm findings on the live app |
| Release | Own go/no-go when policy requires it | Run the pipeline, smoke gates, rollback |
| Operations | Approve the fix and the customer message | Watch production, diagnose, draft the change |

## A short checklist you can run this week

Score your current loop. Two or more gaps means you have AI-assisted developers, not an AI SDLC framework.

- Every change starts from a testable spec, not a chat that nobody else can replay.
- Builder output lands as a branch with a diff you can revert.
- Policies, not heroics, decide what merges without a human.
- Tests that represent real user flows run on every change and can block publish.
- Security findings are confirmed against the running app, not only a static report.
- Publish has smoke gates and a rollback you have actually used.
- Something watches production and can name a root cause without waiting for a user ticket.
- An audit trail answers who prompted, who approved, and what shipped.

## How Automo Build implements each phase

Automo is an AI SDLC delivered as a platform rather than assembled from parts. You describe the app in a prompt. The loop around that prompt is the framework.

- **Plan and spec**: Plain-language requests become a plan you can correct before code exists. Start on the Free plan from a prompt. No sales call required.
- **Build**: Builder agents generate real React, TypeScript and Supabase applications you own, on branches, as reviewable diffs.
- **Review and guardrails**: Reviewer agents (CTO, Security, Doctor) plus Guardrails map code into business areas, detect risky changes, apply plain-English policies, record human review and leave an audit trail behind every merge. A human product owner still approves what policy flags.
- **Test and QA**: The QA agent runs deterministic browser replays, self-healing tests, smoke gates before publish and production checks after publish.
- **Deploy**: The deploy pipeline publishes through those gates to Automo cloud, your own AWS, Azure or GCP account, private VPC, or on-prem under separate terms, with rollback as a first-class operation.
- **Operate and monitor**: Doctor, a read-only AI SRE, probes the live app, DNS and CDN, diagnoses root cause and drafts the fix for human approval.

## Where to start

You do not need a new department to run this framework. You need the six phases to exist as defaults, not optional ceremony. Automo Build puts them on the same path as the prompt: Free plan, monthly credits, no card. Describe the app and the loop runs. For the product map of each phase, continue to [AI SDLC tools](/learn/ai-sdlc-tools). For the definition this framework sits on, keep [What is an AI SDLC](/learn/what-is-an-ai-sdlc) next to this page.

## FAQ

**What is an AI SDLC framework?**

An AI SDLC framework is the operating model for running software delivery with AI agents: plan and spec, build, review with guardrails, test, deploy, and operate. Humans set direction and approve consequential changes; agents do the production work under policy.

**How is an AI SDLC framework different from a classic SDLC?**

The stages are familiar. The unit of work, the control point, and the evidence change. Agents produce versioned diffs at high volume, policies triage review, tests gate every change, and an audit trail records prompt to production. A classic SDLC is organized around hand-offs between specialists. An AI SDLC framework is organized around governance.

**Do we still need developers and a product owner?**

Yes. Humans own intent, architecture, residual risk, and go/no-go on flagged changes. Agents carry implementation volume, draft reviews, run tests, and diagnose production. The framework exists so that human accountability still works at AI speed.

**What guardrails belong in the review phase?**

Policies that classify changes by business area and risk, protected zones that refuse casual edits, recorded human approval for consequential merges, and an immutable trail of who prompted and who approved. On Automo, Guardrails plus CTO, Security and Doctor reviewers supply that layer.

**How does Automo Build implement this framework?**

Builder agents implement the plan in real code you own. Reviewer agents (CTO, Security, Doctor) and Guardrails govern merges. The QA agent tests with browser replays and smoke gates. The deploy pipeline publishes with rollback. Doctor watches production. You can start from a prompt on the Free plan.

## Related

- [What is an AI SDLC?](https://automo.build/learn/what-is-an-ai-sdlc)
- [AI SDLC tools](https://automo.build/learn/ai-sdlc-tools)
- [Guardrails: the govern stage](https://automo.build/platform/guardrails)
- [Automo vs traditional development](https://automo.build/compare/traditional-software-development)
- [Prototype to production](https://automo.build/use-cases/prototype-to-production)
- [Pricing](https://automo.build/pricing)

Canonical page: https://automo.build/learn/ai-sdlc-framework
Site overview for agents: https://automo.build/llms.txt
