Services How we work Industries Work About Blog Book a call

The agentic AI SDLC: AI agents, thirteen phases.

Our delivery lifecycle runs on a system of AI agents working together across thirteen phases, from discovery to continuous improvement. Senior engineers approve every plan and every merge. This is the same agentic system we build for clients. This page explains what happens in each phase, what you review, and what you approve.

The AI SDLC, phase by phase.

01Discovery

Understand the business context, stakeholders, and constraints before anything else.

Output: the business problem written down in plain English, the input every later phase plans from.

02Business Analysis

Map current processes and quantify where software (and AI) changes the economics.

Output: an analysis of that requirement, which the design is built on.

03Requirements Gathering

Turn goals into testable, prioritized requirements: AI-assisted, human-approved.

Output: testable, prioritized requirements. Gate: you approve them before design starts.

04Planning

Scope, milestones, staffing, and risk register agreed before build begins.

Output: a written, dependency-ordered plan. Gate: an engineer approves it before any build task starts.

05UI/UX Design

Interfaces designed around real workflows, validated with prototypes.

Output: validated prototypes. For a new website, ten homepage designs on one comparison page, and you pick one.

06System Architecture

An architecture reviewed against your expected load and growth, not just today's traffic.

Output: the system design. Gate: you approve the architecture before development, and a reviewer argues against each design decision before merge.

07Development

Senior engineers shipping in tight, AI-assisted loops with mandatory code review.

Output: code built task by task. Gate: a build check after every task, and the result reconciled against the plan.

08Testing

AI-generated test suites reviewed by engineers; regression runs on every merge.

Output: QA scenarios written from the acceptance criteria, negative paths included. Gate: fixes verified in a real browser and with real API calls.

09Quality Assurance

Manual exploratory passes and acceptance criteria sign-off per milestone.

Gate: two independent reviewers, then a three-reviewer governance review. A pull request cannot open with a high-severity finding.

10Deployment

Automated, repeatable releases with rollback plans as standard.

Output: a version bump, a changelog entry and a release tag with every change. Gate: deploys are blocked on errors.

11Monitoring

Observability and alerting from day one in production.

Gate: fixes are verified outside production, never against it.

12Maintenance

Patches, dependency updates, and performance care on a defined cadence.

Output: documentation bound to the code. A code change marks a page stale until an engineer re-verifies it.

13Continuous Improvement

Production telemetry feeds the roadmap. The lifecycle never really ends.

Output: lessons written as rules a person approves, for one engineer, one codebase or the whole company.

Secure SDLC: how every change is checked

The thirteen phases say what happens. This is how each change inside them is planned, built and checked before it reaches your codebase. Senior engineers run every step; the AI tooling works for them.

The delivery loop

  1. 01RequirementA plain-English request.
  2. 02Written planDependency-ordered. An engineer approves it.
  3. 03Build, task by taskA build check after every task.
  4. 4Four quality gatesEach one must pass before the merge.
  5. 05Merge and handoverA report of what was planned, delivered and changed.
Our delivery loop: a requirement becomes a written plan that an engineer approves, is built task by task with a check after each, passes four quality gates, then merges with a handover record.

Independent review

  1. 1One changeBuilt and checked against its plan.
  2. 2Two reviewers
    • Reviewer one, fresh context
    • Reviewer two, a different model family where available
  3. 3Governance review
    • Security, with a concrete exploit scenario
    • Architecture, arguing against each design decision
    • The codebase's own conventions
  4. 1One verdict
    • Approved
    • Approved with conditions
    • Blocked
Two independent reviewers check each change without seeing each other's verdict, and both must pass; after three rounds a senior engineer decides. Three more reviewers then work in parallel on security, architecture and codebase conventions, and their findings produce one logged verdict.

Before any pull request opens

  • The build has zero errors.
  • No leftover TODO or FIXME markers.
  • Endpoints carry authorization and rate limiting wherever the codebase uses them.
  • No high-severity security findings.

Lessons become rules

What one project teaches is written down as a rule that guides the next, at one of three levels: one engineer, one codebase, or the whole company. A person approves every rule before it is written.

Documentation that knows when it is stale

Each codebase gets documentation bound to the code it describes. When that code changes, the page is flagged stale; only re-reading the code and re-verifying returns it to fresh. Engineers see the relevant page when they open a file.

How the AI SDLC runs on Claude Code

The delivery loop above runs inside Claude Code, Anthropic's coding agent. Each part below links to Anthropic's own documentation, so you can check what the feature does. A few checks stop the work; the rest advise, and an engineer decides.

Hooks

Scripts Claude Code runs at set points. Five of ours stop the work: a pasted credential, an edit before the approved plan is saved, a known secret in a command, a deploy with audit errors, and an overfull context. The rest advise. Anthropic's hooks documentation

Plan mode

Claude Code proposes a plan and changes nothing until an engineer approves it. A hook then holds the first edit until that plan is saved, so the work is checked against the plan that was approved. Plan mode documentation

Skills and slash commands

Nineteen skills and 46 slash commands hold our procedures for planning, review, security testing and deploys, written once and reused. They guide the work; they do not enforce it. Skills documentation

Subagents

Reviewers run as separate agents with a fresh context, and parallel changes are built in isolated copies of the repository. The reviewers report findings; an engineer decides. Subagents documentation

MCP servers and plugins

Browser testing, documentation lookup and a map of the codebase are connected as tools, alongside plugins from Anthropic's own marketplace. MCP documentation

CLAUDE.md

Team rules load into each session as context. Anthropic's docs describe this as context, not enforcement, so a rule that must hold gets its own hook instead. Memory documentation

Which checks block, what happens when one fails, and what to ask any Claude Code agency: read the full breakdown. Claude and Claude Code are trademarks of Anthropic, PBC. We are independent and not affiliated with or endorsed by Anthropic.

Common questions

Yes. Every engagement follows the same thirteen-phase framework, scaled to its size. The sequence is fixed so nothing is skipped quietly; the effort inside a phase is not.

A system of specialized AI agents works inside every phase: drafting requirements, generating and reviewing code, authoring tests, and watching production. Senior engineers review and approve what the agents produce at each step.

You approve at each phase boundary: requirements before design begins, system architecture before development starts, and a working demo at every build milestone.

Yes. Work on an existing system opens with an architecture review and delivery audit, so the remaining phases run against a documented baseline rather than assumptions.

Two independent reviewers check every non-trivial change without seeing each other's verdict, and both must pass. A governance review then checks security, architecture and the codebase's own conventions, and no pull request opens with a high-severity finding. Senior engineers approve every plan and every merge.

Yes. Client credentials live in a vault on the engineer's machine, never in the repository. Our AI tools work with a secret's name only and never see its value, output is masked, and a secret pasted into a chat is blocked before it reaches the AI.

Want this agentic system running on your project?

Book a call and we'll show you how the same AI-agent SDLC can run on your team's next build, phase by phase.