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.
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.
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.
Map current processes and quantify where software (and AI) changes the economics.
Output: an analysis of that requirement, which the design is built on.
Turn goals into testable, prioritized requirements: AI-assisted, human-approved.
Output: testable, prioritized requirements. Gate: you approve them before design starts.
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.
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.
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.
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.
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.
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.
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.
Observability and alerting from day one in production.
Gate: fixes are verified outside production, never against it.
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.
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.
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.
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.
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.
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.
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
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
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
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
Browser testing, documentation lookup and a map of the codebase are connected as tools, alongside plugins from Anthropic's own marketplace. MCP documentation
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.
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.