AI-SDLC

What is an AI SDLC? Running the software lifecycle with agents, phase by phase

Last updated

This guide explains the AI SDLC, uses the open AI-SDLC framework as its worked example, and walks the lifecycle one phase at a time. An AI SDLC, which people also call an AI-native SDLC or an agentic SDLC, is an AI software development lifecycle in which coding agents carry out much of the work and people keep the decisions. For each phase you get what changes, how to start, the control that keeps it safe, and what to measure, with a link to the documentation behind every claim.

What is an AI SDLC?

An AI SDLC is a software development lifecycle in which AI coding agents perform a large share of the work in every phase, from turning a request into a task through writing, reviewing, testing, shipping and operating the code, while humans decide what gets built, set the rules the agents work under, and check the evidence that those rules held. The same idea goes by two other names: an AI-native SDLC, which stresses that the process is designed around agents from the start rather than bolted on, and an agentic SDLC, which stresses that agents act on their own between checkpoints instead of only suggesting text. All three describe one AI software development lifecycle. What separates it from a team that simply uses an assistant is that the lifecycle itself is written down as configuration, and controls in the pipeline, not habits, decide what an agent may do next.

The phases are the familiar ones. Requirements still have to be clear, designs still have to hold together, code still has to be reviewed and tested, and releases still need a rollback plan. What moves is the bottleneck. When an agent can draft a change in minutes, the scarce resource stops being typing and becomes judgment: knowing what to ask for, deciding whether the result is right, and proving afterwards that the checks ran.

That shift is the core of the AI-SDLC primer, which describes the framework this guide uses as its example. AI-SDLC is an open specification with a reference implementation: you declare the lifecycle as resources such as pipelines, quality gates and autonomy policies, and controllers reconcile what the agents actually do toward that declaration.

How does an AI SDLC differ from a traditional SDLC?

In a traditional lifecycle, people do the work and process mostly coordinates them. In an AI SDLC, agents do much of the work and process has to constrain them, because an agent will happily continue past the point where a person would stop and ask. The table compares the two, phase by phase. The sections after it take each row in turn.

PhaseTraditional SDLCAI SDLC
Requirements and planningTickets can stay loose because the engineer fills gaps in conversationTasks must be decided before dispatch; a readiness gate refuses vague ones
DesignDesign lives in documents and meetingsDecisions are recorded as artifacts at the right altitude before any agent starts
ImplementationEngineers write code under team conventionsAgents write code under declared limits on actions, paths and change size
Code reviewA colleague reads the diffIndependent reviewer agents on a different harness check it and leave signed evidence
TestingCoverage and suites are a team normCoverage and suites are gates with an enforcement tier
SecurityScans run and findings are triaged laterScans block merges, and untrusted input is handled structurally
Release and deploymentA person merges and deploysMerge and deploy rights follow policy and an earned autonomy level
Operations and maintenanceDashboards track the serviceMetrics also track agents, cost and autonomy, with an append-only audit trail

Phase one: requirements and planning

Planning is where an AI SDLC wins or loses most of its value. An agent given a vague request does not ask a clarifying question over coffee; it guesses, and a confident guess produces a plausible pull request that is wrong in ways that take longer to find than the change took to write.

What changes

The task becomes a contract. It has to name what done looks like in terms a machine can check, the files or routes it touches, and any decision a person still owes. In AI-SDLC the spec-driven development guide lists a seven-point readiness rubric, including binary-testable acceptance criteria, a named affected surface and scope bounded to roughly one pull request. Planning also gains a routing decision: how much human involvement a task needs, based on how hard and how risky it is.

How to start

  1. Pick one repository and rewrite its next few tickets so each one states acceptance criteria a test or a reviewer could answer with yes or no.
  2. Turn on the Definition-of-Ready gate in advisory mode and read what it flags before you let it block anything.
  3. Add complexity routing to your pipeline so trivial changes and risky ones take different paths, as shown in Tutorial 1.
  4. Agree who answers the questions the gate sends back, and how quickly, so refused tasks do not sit idle.

The governance control

The readiness gate is the control. It runs cheap deterministic checks first and a semantic evaluation second, and returns one of three verdicts: passed, needs clarification, or blocked. Only passed tasks are dispatched. The routing table below, copied from the basic pipeline tutorial, maps a complexity score to one of four strategies, from fully autonomous to human-led.

Complexity routing in a Pipeline resource
routing:
  complexityThresholds:
    low:
      min: 1
      max: 3
      strategy: "fully-autonomous"
    medium:
      min: 4
      max: 6
      strategy: "ai-with-review"
    high:
      min: 7
      max: 8
      strategy: "ai-assisted"
    critical:
      min: 9
      max: 10
      strategy: "human-led"

Source: Tutorial 1: Setting Up a Basic Pipeline

What to measure

Track how often the gate sends a task back and why, and whether tasks that passed still needed rework in review. A falling rework rate on passed tasks tells you the rubric is catching the right things. The gate keeps a calibration log of its semantic evaluations so you can see false positives and false negatives, as the Definition-of-Ready gate page describes.

Phase two: design

Design in an AI SDLC is less about drawing boxes and more about deciding things early enough that no agent has to decide them for you. An agent will choose a caching strategy or a data model if nobody else has, and it will choose consistently with its training rather than with your architecture.

What changes

Decisions become artifacts at a chosen altitude. AI-SDLC describes three tiers in its spec-driven development guide: an RFC for a genuinely open, cross-cutting question; a spec for a feature that spans several tasks; and a task for one deliverable. Most day-to-day work skips straight to the task tier, but nothing skips the task, because the task is what the pipeline executes. The design phase is where you decide which altitude a piece of work belongs at, and you write the artifact before anyone dispatches anything.

How to start

  1. List the open questions in your next feature and ask of each whether reasonable engineers would disagree; those become decision records, the rest go straight into tasks.
  2. If your team already drafts specs with a front-of-funnel tool, follow the spec-kit bridge tutorial to import the resulting task list as gated backlog tasks.
  3. Link every task to the decision or spec it implements, so a reviewer can check the change against intent rather than against the diff alone.

The governance control

The control here is the same readiness gate, seen from upstream: a task that still hides an open design question fails the rubric and comes back to a person. In AI-SDLC, decisions are routed to a human actor, never settled by an agent acting alone, which the spec-driven development guide frames as the operator remaining the decision steward. For user-interface work, the design review architecture splits mechanical checks from judgment calls so each gets the right reviewer.

What to measure

Count how many tasks fail the gate for an unresolved decision and how long those decisions take to close. If agents keep surfacing the same kind of question, the gap is in your design practice, not in the agent. A second signal is drift: pull requests that a reviewer rejects because they contradict an earlier decision.

Phase three: implementation

Implementation is the phase people picture when they hear agentic development, and it is the one that needs the least new thinking, provided the earlier phases did their job. The agent reads the task, edits the code, runs the tests it is allowed to run, and opens a change. The interesting work is in the limits around it.

What changes

The engineer's role moves from author to supervisor of a bounded process. The bounds are explicit: which commands an agent may run, which paths it may touch, how large a change may be, and whether tests must accompany it. In AI-SDLC these live in a version-controlled policy file per repository, described in per-repo governance, and the same resolved policy is rendered into every agent session, so what the agent is told and what it is prevented from doing are one thing.

How to start

  1. Start agents at a low autonomy level where every change is a draft pull request a person approves, as the progressive autonomy tutorial sets out.
  2. Write the commands and paths you never want an agent to use into the repository's agent role file before the first run, not after the first incident.
  3. Cap change size so each pull request stays small enough to review in one sitting.
  4. Require tests with every change, and treat a change without them as incomplete rather than as a reviewer's problem.

The governance control

The control is runtime action governance: blocked commands and paths enforced by the orchestrator and by hooks in the agent's own session, so a forbidden merge or force-push is refused rather than merely discouraged. The excerpt below comes from the action governance reference.

Blocked actions and paths in agent-role.yaml
apiVersion: ai-sdlc.io/v1alpha1
kind: AgentRole
metadata:
  name: coding-agent
spec:
  constraints:
    blockedActions:
      - 'gh pr merge*'        # Raw merge skips the gate; use cli-merge-if-eligible (see governance.allowMerge)
      - 'git merge*'          # No merging into main
      - 'git push --force*'   # No force push
      - 'git push -f*'        # No force push (short flag)
      - 'gh pr close*'        # Only humans close PRs
      - 'gh issue close*'     # Only humans close issues
      - 'git branch -D*'      # No branch deletion (force)
      - 'git branch -d*'      # No branch deletion
      - 'git reset --hard*'   # No destructive resets
      - 'git checkout -- .'   # No bulk discard
      - 'git restore .'       # No bulk restore
    blockedPaths:
      - '.github/workflows/**'
      - '.ai-sdlc/**'
    requireTests: true
    maxFilesPerChange: 15

Source: Action governance reference

What to measure

Measure the share of tasks an agent completes without a person stepping in, and the time from assignment to an open change. The metrics specification defines both, as agent success rate and human intervention rate, and breaks them down by agent and complexity tier so you can see where agents struggle.

Phase four: code review

Review is where most teams first feel an agentic lifecycle strain. Agents open changes faster than people can read them, and the obvious fixes, reading less carefully or letting the authoring agent review itself, both quietly remove the safety the review was there to provide.

What changes

Review stops being one colleague reading one diff and becomes a set of narrow reviewers, each checking one concern, with a person reviewing the spec and the evidence rather than every line. Independence becomes a requirement you can state and verify. In AI-SDLC, cross-harness review runs code, test and security reviewers on a different harness from the implementer, because a reviewer that shares the author's training tends to share its blind spots.

How to start

  1. Separate review concerns into at least correctness, tests and security, and give each its own reviewer and its own verdict.
  2. Make the review stage declare that it must run on a different harness from the implementation stage, so a same-model review is refused instead of accepted.
  3. Start the human-approval rule as an advisory gate, measure how often it would have blocked, then promote it once the team meets it consistently.
  4. Calibrate reviewer agents against known findings using the review calibration tutorial before trusting their verdicts.

The governance control

Two controls apply. A reviewer-based quality gate sets how many human reviewers a change needs and whether an agent-authored change needs an extra one; the excerpt below is the advisory starting point from Tutorial 2. And reviewer independence records where each review ran, as a tier a verifier can re-derive rather than a label the signer asserts.

A reviewer-based QualityGate
apiVersion: ai-sdlc.io/v1alpha1
kind: QualityGate
metadata:
  name: human-approval
  namespace: team-alpha
spec:
  gates:
    - name: minimum-reviewers
      enforcement: advisory
      rule:
        minimumReviewers: 2
        aiAuthorRequiresExtraReviewer: true

Source: Tutorial 2: Adding Quality Gates

What to measure

Watch the share of agent pull requests accepted without modification, the average number of review rounds, and how often reviewers disagree. The metrics specification defines the acceptance rate by author type, so you can compare agent and human changes on the same footing. If review cost is the worry, the staged review pipeline describes how AI-SDLC plans to cut it without lowering the bar.

Phase five: testing

Agents write tests readily, which is both useful and a trap. A suite that an agent wrote to pass its own change proves little on its own, and coverage that drifts down a little with each change is hard to notice until it matters.

What changes

Testing expectations stop being a norm the team remembers and become a gate the pipeline enforces, with a stated enforcement tier. AI-SDLC uses three tiers, described in Tutorial 2: advisory, where a violation is logged and the action proceeds; soft-mandatory, where it blocks unless an authorised person overrides with a justification; and hard-mandatory, where nothing overrides it. The scope of a gate can target only agent-authored changes, so you can hold agents to a stricter bar while you learn.

How to start

  1. Measure current coverage on changed lines before setting any threshold, so the first gate reflects reality rather than ambition.
  2. Add a coverage gate scoped to agent-authored changes at soft-mandatory, with a named role allowed to override and a justification required.
  3. Have a separate test reviewer check that new tests exercise the behaviour in the acceptance criteria, not only the lines that changed.

The governance control

The coverage gate is the control. In the example from Tutorial 2, changes by agents in matching repositories must meet a line-coverage threshold, and only an engineering manager may override a failure, with a reason on record.

A metric-based coverage gate
apiVersion: ai-sdlc.io/v1alpha1
kind: QualityGate
metadata:
  name: test-coverage
  namespace: team-alpha
spec:
  scope:
    repositories: ["org/service-*"]
    authorTypes: ["ai-agent"]
  gates:
    - name: line-coverage-check
      enforcement: soft-mandatory
      rule:
        metric: line-coverage
        operator: ">="
        threshold: 80
      override:
        requiredRole: engineering-manager
        requiresJustification: true

Source: Tutorial 2: Adding Quality Gates

What to measure

Track gate overrides as closely as gate failures. The metrics specification defines an override rate for exactly this reason: a gate that is overridden often is either set wrong or being worked around. Pair it with defect density by author type to see whether agent changes that pass the gate hold up afterwards.

Phase six: security

An agent with write access reads a lot of text it did not choose: issues, comments, pull requests from strangers, dependency metadata. Any of it can carry instructions. Security in an AI SDLC therefore covers both the code the agent writes and the inputs that steer it.

What changes

Scans move from advisory reports to gates that block the merge, and they apply to everyone, not only to agents. The larger change is structural handling of untrusted input. AI-SDLC's zero-trust verification of untrusted changes explains how automation can review outside contributions without privilege escalation, credential theft, forged results or hijacked reviewers, and the security reference covers sandboxed execution, just-in-time credentials, kill switches and approval workflows.

How to start

  1. Add a static-analysis gate at hard-mandatory that applies to both agent and human authors.
  2. Block agents from editing workflow files and governance configuration, so a compromised run cannot loosen its own rules.
  3. Treat every pull request from outside your organisation as hostile input and run its verification without secrets.
  4. Give the security reviewer the strongest reasoning model you route to, and make its verdict a merge condition.

The governance control

The tool-based gate below, from Tutorial 2, runs Semgrep with an OWASP ruleset and fails on any finding at medium severity or above. Because it is hard-mandatory, it has no override block, and one added later would be ignored.

A tool-based security gate
apiVersion: ai-sdlc.io/v1alpha1
kind: QualityGate
metadata:
  name: security-standards
  namespace: team-alpha
spec:
  scope:
    authorTypes: ["ai-agent", "human"]
  gates:
    - name: semgrep-security-scan
      enforcement: hard-mandatory
      rule:
        tool: semgrep
        maxSeverity: medium
        rulesets:
          - "owasp-top-10"

Source: Tutorial 2: Adding Quality Gates

What to measure

Measure the security scan pass rate by author type, which the metrics specification defines, and count blocked actions and refused untrusted runs. A sudden rise in blocked actions from one agent is worth reading before it becomes an incident.

Phase seven: release and deployment

Merging and deploying are the points of no easy return, so they are where an AI SDLC concentrates its proof. A green check that says a workflow finished is not the same as evidence that a real review ran against the exact change being shipped.

What changes

Merge rights become a declared policy instead of a convention. In AI-SDLC the strict default is that agents never merge; a repository can relax that, for example to allow a merge once every check is green and the merge state is clean, and the resolved policy is what the audit log records, as per-repo governance explains. Deploy rights follow autonomy: in the policy from the progressive autonomy tutorial, only the highest level may merge non-critical changes or deploy to staging.

How to start

  1. Keep merges human until review evidence is in place and verified in continuous integration.
  2. Require a signed attestation for every agent change and have the merge gate check it, not just the presence of a passing workflow.
  3. Decide in writing which change classes, if any, an agent may merge on its own, and record that decision in the repository policy.

The governance control

Proof of Execution is the control. Each reviewer's transcript is hashed into a leaf, the leaves form a Merkle root bound to the content of the diff, the operator signs the envelope, and continuous integration recomputes the root before merge. A reviewer that never ran leaves no leaf, so the envelope fails to verify. The white paper gives the full design and threat model.

What to measure

Measure deployment frequency, lead time, change failure rate and time to restore, the delivery metrics the metrics specification builds on, and add rollback rate per agent. Rollback rate matters twice in an AI SDLC: it is a delivery signal, and in the progressive autonomy tutorial it is also a promotion criterion and a demotion trigger.

Phase eight: operations and maintenance

Once agents are part of how software changes, they are part of what you operate. You watch the service, and you also watch the agents: what they cost, how often they need help, and whether the trust you extended is still earned.

What changes

Observability gains new subjects. The metrics specification defines five categories, task effectiveness, human-in-loop indicators, code quality, economic efficiency and autonomy trajectory, and requires provenance on every AI-generated artifact: the model, the tool, a hash of the prompt and a timestamp. It also requires an immutable, tamper-evident audit entry for every action; the audit reference implements it as an append-only, hash-chained log.

How to start

  1. Export the agent metrics into the observability stack you already run, using the OpenTelemetry conventions in the metrics specification.
  2. Record every model call in a usage ledger so spend can be attributed to roles, tasks and models.
  3. Declare demotion triggers before you promote any agent, so a serious incident lowers its autonomy automatically.
  4. Review autonomy levels on a schedule, not only after something goes wrong.

The governance control

Autonomy is the control that ties operations back to the rest of the lifecycle. The demotion triggers below, from Tutorial 3, drop an agent to the lowest level after a critical security incident or an unauthorised access attempt, and one level when its rollback rate rises too far, each with a cooldown before promotion is reconsidered.

Demotion triggers in an AutonomyPolicy
demotionTriggers:
  - trigger: critical-security-incident
    action: demote-to-0
    cooldown: "4w"
  - trigger: rollback-rate-exceeds-5-percent
    action: demote-one-level
    cooldown: "2w"
  - trigger: unauthorized-access-attempt
    action: demote-to-0
    cooldown: "4w"

Source: Tutorial 3: Configuring Progressive Autonomy

What to measure

Track cost per task, the intervention trend over time, and each agent's level. The model routing cost guide shows how routing roles to cheaper models bounds spend, and the usage ledger page explains why the routing table is read from the base branch, so a pull request cannot reroute itself.

Where do governance, autonomy levels and audit evidence fit?

Most writing about the AI SDLC stops at the phases. The phases are necessary but they are not what makes the lifecycle trustworthy. Three cross-cutting pieces do that, and they are the part of AI-SDLC a generic lifecycle model does not give you.

Governance is the set of rules an agent works under, written as configuration in the repository and enforced at runtime rather than requested in a prompt. Every claim this site makes about those rules is listed with the page that backs it in the proof index, and the security page states what the framework protects and what it does not.

Autonomy levels decide how much an agent may do without a person. The progressive autonomy specification defines the levels, the promotion criteria an agent has to meet with measured results, and the triggers that move it back down. The agent autonomy levels guide summarises them for a buyer.

Audit evidence is what lets someone check, months later, that the rules held. The Proof of Execution white paper explains how review evidence is signed and committed next to the code, and the compliance by design guide shows how a declared posture drives gate strictness and retention. The compliance reference lists the regulatory frameworks the controls map to; a mapping is not a certification, and whether a deployment satisfies a regulation is for your compliance team to confirm.

Does an AI SDLC lock you into one coding agent?

It should not, and AI-SDLC is built so it does not. The framework governs agents rather than replacing them: the orchestrator invokes coding agents through one runner interface, and the agent runners reference lists the built-in runners for Claude Code, GitHub Copilot CLI, Cursor and OpenAI Codex CLI, plus a generic runner for any OpenAI-compatible chat completions API.

Being able to mix agents is also what makes independent review practical. When the implementer and the reviewer run on different harnesses, their mistakes are less correlated, which is the argument behind cross-harness review. You bring your own keys and your own tools; the governance layer stays the same whichever agent does the work.

Where to start

You do not need to adopt every phase at once. A sensible order is planning and review first, because a readiness gate and independent review change the economics of agent work fastest, then add testing and security gates, and only later relax merge rights as evidence accumulates.

For a staged plan, read how to get started with AI-SDLC. To see where your team stands today, take the self-check. When you are ready to run it, the getting-started guide installs the tooling on one repository and walks you through a first pipeline.