Delivery lifecycle
AI does not run your project. Engineers with twenty years of production experience run your project, and use AI inside each phase to do in hours what used to take weeks. No phase advances because a tool reported success — it advances when the engineer responsible for it is satisfied with the output.
Every phase has a named owner. That owner reviews the output of the phase before the next one starts. If they are not satisfied, the phase repeats. This is the difference between AI-assisted engineering and hoping a model got it right.
Establishing what is actually being built, and whether it should be.
Senior engineer owns
Challenges the premise. Decides what the one thing the product must do is — and says so if software is not the answer.
AI accelerates
Researches comparable products, surfaces prior art and the failure patterns common to this category.
Gate · A single sentence describing what the product must do, that you agree with.
Senior engineer owns
Runs the sessions and asks the questions your stakeholders did not think to answer.
AI accelerates
Transcribes, structures and de-duplicates input; drafts the initial requirement register.
Gate · Every requirement has a named owner and a stated reason. Unowned requirements are cut.
Senior engineer owns
Finds the contradictions between requirements and decides which one wins.
AI accelerates
Cross-checks the full set for conflicts, gaps and untestable statements at a scale humans miss.
Gate · Every requirement is testable, or it is rewritten until it is.
Senior engineer owns
Makes the call on what is achievable within your budget and timeline — including telling you when it is not.
AI accelerates
Models technical, financial and operational scenarios; checks integration, licensing and data constraints.
Gate · A written go / no-go decision, with the assumptions it depends on listed.
Committing to a sequence, a number, and an architecture.
Senior engineer owns
Owns the estimate and the sequencing, and is accountable if it turns out wrong.
AI accelerates
Decomposes scope into work items and produces a first-pass estimate for the engineer to challenge.
Gate · Estimate reconciled against comparable past delivery, with contingency stated explicitly.
Senior engineer owns
Decides the architecture. This is the phase we delegate least — it is where the expensive mistakes live.
AI accelerates
Generates candidate designs and side-by-side trade-off comparisons to argue against.
Gate · A signed architecture decision record, including the options rejected and why.
Turning the decision into something buildable and agreed.
Senior engineer owns
Decides the flows, and decides what to remove.
AI accelerates
Generates screen variants, empty and error states, and interface copy against the agreed flow.
Gate · A clickable prototype walked through with you, start to finish.
Senior engineer owns
Confirms the specification matches intent, not merely the requirements as written.
AI accelerates
Drafts the FSD from the requirement register and the prototype.
Gate · Your sign-off, with explicit acceptance criteria attached to every function.
Senior engineer owns
Owns the data model, the interfaces and the non-functional targets.
AI accelerates
Drafts schemas, API contracts, sequence diagrams and migration plans.
Gate · Data model reviewed for evolvability — the one decision that is genuinely expensive to reverse later.
Where the six-stage delivery pipeline runs, on every single change.
Senior engineer owns
Sets the conventions, reviews every diff, and throws away what is wrong.
AI accelerates
Generates services, schemas, endpoints and interfaces against the technical design.
Gate · Nothing reaches the main branch without a named senior engineer approving it.
Senior engineer owns
Final judgment on every change — and reviews refactors harder than features, because that is where behaviour changes hide.
AI accelerates
Adversarial pre-review on every diff: authorisation gaps, injection paths, N+1 queries, unsafe dependencies.
Gate · Machine review clean, then human approval. Both are required, in that order.
Senior engineer owns
Decides the failure behaviour for every external dependency before it is wired in.
AI accelerates
Generates clients, mocks, retry and backoff logic, and contract tests.
Gate · Every integration has a defined, tested fallback path. No silent failures.
Blueprint → Forge → Redline → Senior review → Proof → Ship. Two of those six are mandatory human gates. That loop repeats for every individual change; this page is the lifecycle around it.
See the delivery pipelineProving it does what was agreed in phase 08.
Senior engineer owns
Verifies the tests assert the requirement rather than the implementation — the most common way generated test suites are worthless.
AI accelerates
Generates and maintains suites against the acceptance criteria agreed at phase 08.
Gate · UAT signed by you. Coverage that maps to requirements, not to lines of code.
Senior engineer owns
Decides what is a defect and what is a change request, and triages by real user impact.
AI accelerates
Reproduces, localises root cause, proposes fixes and profiles slow paths.
Gate · No known severity-1 or severity-2 defects open at release.
Getting it live, documented, and into your team's hands.
Senior engineer owns
Authorises the release. A person makes this call, never a pipeline on its own.
AI accelerates
Runs the build and deploy pipeline, and prepares the rollback path.
Gate · Rollback tested before approval. The release is reversible before it is permitted.
Senior engineer owns
Checks accuracy against the built system. Confidently wrong documentation is the most common failure of generated docs.
AI accelerates
Drafts user guides, API references and operational runbooks from the code and the FSD.
Gate · Documentation verified against the shipped build, not against the specification.
Senior engineer owns
Runs the sessions with your engineers and answers the difficult questions live.
AI accelerates
Prepares walkthroughs, environment setup guides and worked examples.
Gate · Your team completes a real task in the system without our help.
After launch — where most of a product's life actually happens.
Senior engineer owns
Owns the SLA and the escalation path, and is on the call when it matters.
AI accelerates
Monitors, correlates alerts, triages by severity and drafts first-response diagnostics.
Gate · Every incident closes with a post-incident note written by a person.
Senior engineer owns
Decides what to build next from usage evidence — and what to remove.
AI accelerates
Surfaces usage patterns, performance regressions and infrastructure cost drift.
Gate · Each iteration re-enters the lifecycle at the phase it needs, not back at the start.
Why this matters
It is a fair question and we get it on most calls. The honest answer is that AI does a great deal of the work inside these phases, and none of the deciding between them. Nineteen phases, nineteen named owners, each with two decades of shipping behind them. That is what you are buying.
A 30-minute call with an engineer, not a salesperson. You’ll leave with a scope, a timeline and a number — or an honest reason why we aren’t the right fit.