Browse the reference ⌄
Implementation Guide published

The Agent-Speed SDLC

A committed artefact chain, governed context, trusted tests and eight SDLC controls that let coding agents work quickly while intent, review, identity and evidence stay connected.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
29 min

For Cto · Ai Architect · Platform Engineer · Product Leader · Risk And Assurance · Internal Audit

Sources and details
Source works
Book 1 · Book 2 · ADD proposal · Book 3 · Book 09
Source chapters
1, 2, 3, 4, 5, 6, 8, 13, 14, 15, 28
Source appendices
01:F
Refresh trigger
source change

Full source list ↓ Source index →

Use this page when coding agents contribute changes to a governed software product. It sets out the committed artefact chain the agent works through, the context it reads, the tests you can trust, the eight SDLC controls that hold AI-assisted code, and the evidence an auditor will ask for. It assumes the factory model and complements release engineering, which covers promotion and recovery, and change governance, which covers risk routing.

intent.md → spec.md → plan.md → diff + tests → PR + review findings
          → release + evidence → monitoring → new intent.md
The committed artefact chain from intent to monitoring, where every arrow is a commit and the chain is the audit trail.

At a glance: every arrow in the chain is a commit, so the chain is the audit trail. The detailed diagram is under Enforce the chain at commit boundaries. Source: The AI Delivery Factory, Chapter 15, Figure 15.1.

What AI changes in the SDLC: four amplified failure modes

Both Book 1 (Ch 15 §4.1) and Book 2 (Ch 14 §3) make the same claim: AI does not create new kinds of SDLC failure, it pushes four existing ones past the level today’s controls were sized for. Use them as one diagnostic. Volume makes plausibility dangerous; plausibility left unchecked becomes drift; attribution is what fails you when any of the other three turns into an incident.

Failure modeWhat you seeTechnique that answers it (Book 2)Book 1 controls (below)
Volume: more change arrives than reviewers can absorbReview latency climbs while headcount stays flat; one-reviewer, quick-look merges; quality loss shows up as incidents weeks laterRisk-routing gate that sends low-risk, well-evidenced change to automated approval and keeps people for the rest (change governance)1, 2
Plausibility: output looks finished before it is proven correctIdiomatic, green, coherent changes that solve a slightly different problemSpec-driven development with plan-then-execute; tests with an independent source (see test provenance)3, 4
Drift: generated work converges on the model’s defaults, not your architectureThree patterns for the same concern across services; unsanctioned libraries; data joins that silently change meaningStanding context, ADRs enforced as hooks/CI, recipe-bound workspaces5, 6
Attribution: authorship and accountability blurCommits under a human’s account that the human never read; anonymous bot committers; no on-call owner for an agentAgent identity carried into the evidence record, with a named wrangler as accountable human7, 8

Composite illustration (Book 1, Bank A): a credit-risk team where about a hundred developers each opened five AI-assisted pull requests a day within eight weeks of an assistant rollout. The response was not to slow developers down but to make automated gates carry the first pass.

The stages and their gates

Every stage commits an artefact before the next stage depends on it. The commit chain is the traceability trail; it feeds the evidence record.

StageCommitted artefactHuman decision or deterministic control
Plan the workintent.md: problem, outcome, users and constraints in the originator’s wordsProduct owner accepts or rejects the intent; risk tier and data class are assigned.
Designspec.md: testable requirements and designProduct owner resolves concerns with policy owners. Skills advise during drafting.
Buildplan.md, then the code diffThe agent proposes files, order, tests and risks. Its wrangler approves the plan before code is written.
TestTest runs and evaluation resultsDeterministic checks run; the agent cannot change the tests judging its own fix.
DeployPull request, review findings and release manifestCode-owner review and production authorisation happen at their gates.
MaintainMonitoring and incident recordsDeterministic detection triggers a bounded response; incidents become evaluation cases and, where needed, a new intent.

Definition of ready for an agent

Before dispatch, the work item contains or links to: the accepted intent and a measurable outcome; acceptance criteria that can run as checks; affected systems and repositories; data class and personal-data flags; risk tier and required approvals; constraints and explicit out-of-scope items; a named human approver. An item missing any of these is not ready, however capable the agent.

Enforce the chain at commit boundaries

Each downstream artefact names the exact upstream version it used. Give intent, spec and plan stable revision identifiers, carry them in branch/PR metadata and release evidence, and mark derived plans and tests stale when an upstream artefact changes.

A six-stage delivery loop separates human decisions from agent-executed work and commits an artefact at each transition.

The committed artefact chain. Source: The AI Delivery Factory, Chapter 15, Figure 15.1.

BoundaryRequired check before proceeding
Intent → specProduct owner accepted outcome, scope and measurable acceptance; risk/data classification and named owner present.
Spec → planSpec current and versioned; plan names affected files/services, tests, assumptions, risks and out-of-scope work; wrangler accepts it.
Plan → diffAgent identity and permissions bounded; writes restricted to the authorised workspace; protected paths, credential material and new data connections checked deterministically.
Diff → PRAutomated gates pass (control 1); generated test changes are visible and reviewed separately from production changes; PR template complete (control 2).
PR → releaseIndependent human review, policy gates, evaluation and release authorisation recorded against the same change and artefact versions.
Release → operationDeployed versions and configuration captured; monitoring and rollback/disablement active; effects checked against the intended outcome.

The agent that authors a change has no route to approve it. Branch protection requires a human code owner, and the agent may act up to the production gate but not past it. Book 2 (Ch 15 §4.8) treats this as the segregation-of-duties control the firm already owes, not a caution to relax as models improve.

Give the agent the right context

Three context artefacts

An agent reads three things before it acts, and each answers a question it would otherwise answer with a guess (Book 2 Ch 5 §4.1; Book 09 Ch 4):

ArtefactQuestion it answersTypical formOwner
Standing instruction fileHow do we build here? Sanctioned frameworks, identity wiring, logging, “never do” rulesCLAUDE.md, AGENTS.md or equivalent at the repository rootRecommended: platform team (firm layer), domain/architecture lead (domain layer), repo owner (repo layer)
SpecificationBuild this. What the product is and what this change must dospec.md in the repository, beside a current product record (BOM)Product owner
RecipeBuild it this way and no other. The approved assembly, release and evidence patternMachine-readable recipe (BOM and recipes)Platform/recipe owner

Remove any one and the agent fills the gap plausibly. The reason this matters: a deterministic script fails loudly on an incomplete input, whereas a coding agent fills the gap and ships something confident and subtly wrong. In the agent era the description of the product is a control, not just efficiency documentation.

The description must be current (changed in the same commit as the product), queryable (including “what changed near this, when and why”) and machine-read (facts: this field, this owner, this reason, this consumer). When an agent’s work shows the description to be wrong, the agent proposes a correction to it rather than working around it.

Standing context files: owned like code, layered, audited

Standing context is the cheapest architecture-conformance mechanism you have, because it stops non-conforming code being written rather than catching it in review. It is also advice, not enforcement. Run it as follows (Book 2 Ch 14 §4.4, §7, §8; Ch 5 §7 for growing the file from mistakes):

  1. Layer it. A firm-wide baseline, a domain overlay and a repository-specific top. One sprawling file copied and mutated across a hundred repositories is drift disguised as a control.
  2. Own it like code. Versioned, reviewed through PR, dated, with a named owner per layer. Changes to it are policy changes and go through the policy–audit–actuals loop.
  3. Start small and grow it from mistakes. Move one rule your senior reviewers enforce by hand into one repository’s file this week. Then, each time an agent produces output that is right in general but wrong for the firm, add the missing line. Within weeks the file reflects the conventions that were actually ambiguous.
  4. Audit it quarterly. Sample agent output against the file each quarter. Generated code that no longer matches live standards while the file “exists” is the rot signal.
  5. Treat injection as supply chain. Whatever sits in standing context (shared prompts, snippets, recommended internal libraries) will be built into production at machine speed. The pipeline that decides what lands there needs a named owner, an audit trail and a rule that only certified assets are injected (Book 2 Ch 16 §4.5; see the seventh job on the factory model).
  6. No poster values. Every clause placed in agent context must compile into a checkable consequence (a policy rule, a test, a stop condition). Delete clauses that compile into nothing.

Author view (Book 2 Ch 14 §4.4): mainstream, current technology is cheaper to govern by context, because the model already knows its idioms and the file only has to state where the firm departs. A bespoke framework or a stack two major versions behind must be hand-described in standing context and maintained indefinitely.

Measure: the share of review findings that cite a policy already encoded as a skill should fall towards zero. When it stops falling, that rule belongs in a hook, not a skill (Book 2 Ch 15 §5.4). Also count guidelines harvested from “right in general, wrong for the firm” outputs and restarts.

Walls and directions: ADRs, GIPs, skills and hooks

Book 2 (Ch 15 §4.6) separates two kinds of standing rule and puts them in different technical layers:

InstrumentMeaningImplemented asWhen broken
ADR (Architectural Decision Record)A wall: a settled decision you build insideHook, permission rule or CI check when it must holdBlocked. A breach is a defect or incident.
GIP (global internal practice)A direction: followed most of the time, breakable on purposeSkill (advisory guidance the agent loads)Review the practice: change it or record a reviewed exception.

Factory rule: skills advise; hooks, permission rules and CI checks enforce. Anything you must evidence to a supervisor or the second line sits in the deterministic layer without exception. If the answer to “how do you know this cannot happen?” is “the agent has been told not to”, you do not have a control.

Skills are advisory guidance that make compliance likely; hooks are deterministic checks that make a violation impossible.

Source: The AI Delivery Factory, Chapter 15, Figure 15.2.

  • Manage the ADR lifecycle: mark superseded ADRs as superseded, mark decommissioned ones, and keep every ADR, current or superseded, readable by agents. An ADR agents cannot see will be re-derived from training defaults.
  • Agents may propose a new ADR when they hit a genuine gap the spec does not resolve; a human accepts it.
  • Put fast, per-file hooks in the build phase (format, lint, credential scrubbing, protected-path blocks). Put human-approval pauses at deploy gates, not inside build work.
  • Tag every governance item as wall or direction and check its implementation against the tag. A wall implemented as a skill fails silently; a direction implemented as a blocking hook generates weekly exception requests and gets routed around.
  • Managed settings (administrator-controlled allow/deny lists, sandboxing that fails closed, approved tool servers, managed hooks, minimum harness version) stop a local configuration widening the envelope. Calibrate denies to the data classification the workspace can reach. See agent lifecycle and the research paper Securing Claude Code in the Enterprise.

Skills library lifecycle

Encode standards, patterns, runbooks and domain knowledge as version-controlled skills. Subject-matter experts author them; wranglers review and merge them; agents consume them; they are evaluated continuously and updated as the domain changes (ADD proposal §4a.6). A skill change is a governed change with an owner, like any other.

The recipe decides the shape; judgement stays with people

Agents may generate migration scripts, tests, API clients, documentation and infrastructure modules. They may not invent the delivery pattern. Without a recipe a capable agent makes a hundred reasonable small decisions about identity, secrets, logging and deployment, none of them yours, and multiplies the estate’s variety at machine speed (Book 2 Ch 28 §4).

  • Boundary rule: a generated artefact that departs from the recipe is rejected, not accepted as a clever exception. If the departure is right, change the recipe through its owner.
  • A rejection is evidence. Record the generated artefact, the named reviewer, the reason and the corrected version. That record is the proof that meaningful human oversight operated where it should; it should be queryable (“show me where a human overrode the machine on this change”), not reconstructed from chat logs.
  • Judgement dressed as operation. Some work looks mechanical and is not. Composite example (Book 2 Ch 3 §6; Book 09 Ch 2, Asset Manager X): an agent redesigned the matching logic for a custodian’s cash statements, green on every generated test, and silently replaced a configured tolerance with one computed in code. The architect, reviewing second, caught it; the team wrote into the recipe that matching-logic changes are reviewed step by step whatever the agent’s confidence. Encode such boundaries in the recipe so they apply to the next agent too.

Test provenance and the trust order

A test fails only when it knows something the code does not. When one agent writes the code and the tests in the same session from the same spec, they are one reading of the requirement written twice. If the spec is wrong or stale, code and tests are wrong in the same direction and agree. Same-source tests measure faithfulness to the spec, not correctness of the product. Coverage can rise while this independent check disappears (Book 09 Ch 4; Book 2 Ch 3 §6, Ch 14 §8).

Ask where each green test came from, and trust it in this order (Book 09 Ch 4):

TrustTest sourceHow to obtain it (this page’s recommendation)
1 (highest)Written or approved by someone who knows the product as it is nowProduct-owner or domain-expert approved cases; golden records under a named expert
2Owned by a downstream consumerRegister consumers in the product record; the pipeline runs consumers’ contract checks against the change before human review
3Drawn from a source other than the change’s own specTests derived from the current product record, characterisation tests of live behaviour, incident-derived evaluation cases
LowestGenerated with the change from the same specUseful for faithfulness; never sufficient on its own as acceptance evidence

Controls:

  • Record provenance per test (recommended fields: author identity, source artefact, date) and surface it on the PR. The reviewer states it (see the reviewer template below).
  • Feed provenance into risk routing. Code exercised only by agent-written tests scores as riskier; a change that alters a test somebody else wrote scores riskier still (Book 2 Ch 14 §8; Book 09 Ch 8). See change governance.
  • Protect the oracle. The agent may not edit the tests that judge its own change; test changes are reviewed separately from production changes.
  • List the single values that decide what people see (tolerances, thresholds, limits, materiality levels, alert rules). Put the list where the routing gate reads it and send every change to them to a human reviewer, however small the diff. Composite (Book 09 Ch 8): a four-line tolerance change with fourteen green same-source tests was auto-approved and widened a cash-break band about a hundredfold for weeks.
  • Beware negative readiness. Agent-written characterisation tests can entrench existing bugs behind green ticks. Route readiness work through adversarial second-agent review and wrangler sampling, with internal audit sampling the samplers (agent readiness).

The eight SDLC controls for AI-assisted code

Book 1 (Ch 15 §5.1) gives eight controls, two per failure mode. Its labels mark regulatory weight: [REQ] required, [EXP] expected by supervisors, [REC] recommended, [PREF] author preference. The regulatory readings behind [REQ]/[EXP] belong on the regulatory map; this page does not restate them.

#ModeControlImplementation detailBook 1 labelEvidence
1VolumeAutomated review gates pass before a human is asked to lookLint, security scan, architecture conformance, test-coverage delta as required status checks[REC]Check results bound to the PR and commit
2VolumeAI-era PR template with mandatory fieldsAI used, prompt, manual verification, coverage delta, CIF flag (plus the reviewer fields below)[REC]Template fields captured in the PR record
3PlausibilityTwo human reviewers for any PR touching a critical or important function (CIF), regardless of sizePath-based CODEOWNERS rules plus branch protection requiring two approvals on CIF paths[EXP]Two named approvals in the merge record
4PlausibilityMandatory dynamic analysis (DAST) on any change touching authentication, authorisation, payment flows or customer dataPath/label triggers that make the DAST job required for those areas[REQ]DAST report attached to the release
5DriftArchitecture-conformance rules as code at PR timeArchUnit-style fitness functions, not architecture-by-slide[PREF]Fitness-function results per PR
6DriftLibrary and framework choices pinned in a per-repository policy file the assistant reads as contextAllow-list file in the repo, referenced from standing context and enforced by dependency review[PREF]Dependency-review results; policy-file version
7AttributionAgents commit under their own identity; the wrangler is the human of recordRegistered workload identity per agent; never a human’s token or an anonymous bot[REQ]Agent ID and wrangler in the commit/evidence record
8AttributionDeployment identity separate from human developer identity; OIDC federation onlyNo long-lived secrets in pipelines; CI federates to the cloud per run[EXP]Federation configuration; absence of stored deployment secrets

Book 1 Appendix F (§F.6) maps each control to the standard application foundation component that carries it: the deployment pipeline carries controls 1–6 and 8; the role model carries 3 and 7; the security baseline carries 4; the documentation template carries 2 and 5; the configuration model carries 6; identity integration carries 7 and 8.

Scaling (Book 1 Ch 15 §7): a 1,000-person firm can buy conformance tooling rather than write fitness functions and can run a bus factor of two instead of three; deployment-identity separation (control 8) is not reduced at any scale.

CODEOWNERS as a regulated document

Once assistants multiply change, CODEOWNERS decides who is accountable for which path. Treat it as a controlled document (Book 1 Ch 15 §5.3, §8.1):

  • Bus factor of three on every CIF path (two is acceptable at around 1,000 employees).
  • Quarterly review of owners, with the review date recorded; leavers removed; CIF coverage confirmed.
  • Annual attestation by compliance that CODEOWNERS coverage and deployment-identity separation are current across the CIF estate.
  • Gate expansion on it. Tie the next assistant-rollout phase to CODEOWNERS coverage being current.

Failure signal: the platform team can produce CODEOWNERS files but cannot say when they were last reviewed or who would answer for a failure on a given path. Recovery: commission the quarterly review, fix CIF paths first, accept multi-quarter remediation.

An AI reviewer must not replace human review

Configuring an AI agent to perform the review itself removes the last human point of oversight; reviewer-AI and developer-AI converge on plausible, defective changes (Book 1 Ch 15 §8.2).

  • Signals: a measurable drop in PRs with reviewer-requested changes after the AI reviewer is enabled; rising post-merge defects with AI approval in the audit log.
  • Recovery: demote the AI reviewer to a non-blocking commenter; restore a human reviewer on every merge; restore two humans on CIF code.

Agentic review is useful as augmentation. As of March 2026, per Book 3 Ch 13 §4.3, Anthropic reported that its agentic code review raised the share of PRs with substantive review comments from 16% to 54%, with under 1% of findings marked incorrect [FACT-CHECK: Anthropic, “Bringing code review to Claude Code”, 9 March 2026 — confirm figures against the official post]. Book 3’s conclusion stands regardless: it augments the reviewer and does not discharge four-eyes. One named human is accountable per merge, and that name is in the merge record.

Human-review lanes

Let machines assist everywhere, but keep named human review in these lanes (Book 3 Ch 13 §4.3). Base layer, after Anthropic’s published practice for its own engineering organisation (as of June 2026, per Book 3 Ch 13 [FACT-CHECK: Anthropic, “Running an AI-native engineering org”, 3 June 2026]): legal review, security-sensitive code, product judgement. Regulated-firm additions: model-risk-relevant logic; anything touching a CIF; anything in scope of a regulatory reporting obligation; any change to a control’s own implementation.

The human-review boundary: the model handles style, bugs and tests; humans review where domain expertise and regulatory lanes apply.

Machines assist on style, bugs and tests; named humans review the security, model-risk, critical-function and regulatory-reporting lanes. Source: Deploying Claude Safely (Book 3), Chapter 13, Figure 13.1.

Reviewer template and domain questions

Make the PR template carry the reviewer’s evidence, not just the author’s (Book 09 Ch 2, Ch 5):

FieldReviewer records
read_against_planConfirms the change was read against its approved plan.md, not only against itself; diff touches no files the plan did not name.
test_provenanceWhere the tests came from; states explicitly if they came only from the agent.
first_thing_to_checkIn the reviewer’s own words, the one thing they would check first if this change failed.
Domain questionsA fixed set of domain questions owned by the product (e.g. for client reporting: does every figure trace to a generated source; what does the report show when data is missing; which client segments see this and when).

Rule: if the reviewer cannot answer a domain question, they do not approve; they ask. When a review takes long, send back the plan, not the code. These field names are this page’s recommendation; the books describe the content, not a schema.

Identity and data connections at commit time

  • The agent acts under its own identity, interactive or not (Book 2 Ch 15 §4.8). A session borrowing the engineer’s credentials makes the log say the engineer changed forty files, and you can no longer compute the agent-authored share, suspend one agent without the engineer, or answer whether an incident action was human or autonomous. The binding is carried in the AES field executing_agent.agent_id_claim (audit evidence).
  • No service principal used by an agent holds standing production access; break-glass stays with humans (identity and secrets).
  • Check new data connections against registered scope. The pipeline compares any new data source or connection string in a change against the data the product is registered to read, scopes the product identity to that data, and allows configuration to reference secrets only. Composite (Book 09 Ch 5): an endpoint read from a shared reporting database instead of the product’s registered view; had the agent run as its owner, who had support-rota read access, every test would have passed.

SDLC drift becomes data drift

Pipelines that move data are agent-written code in the same repositories. A data product’s dictionary entry is effectively a contract enforced by the code that publishes it; if the code drifts, the contract drifts (Book 1 Ch 15 §4.3).

  • Mechanism 1: an assisted change alters an ETL join key (Book 1’s example: customer_id to external_customer_id). Lint and tests pass, one tired reviewer merges, and downstream records are composed against a key the lineage does not declare, while consuming agents still treat the product as master.
  • Mechanism 2: a code-generation agent builds an MCP tool schema from a stale dictionary entry, codifying the staleness. The loop closes with no human in it.
  • Controls: treat dictionary and lineage updates as governed code changes with the same PR template, reviewer requirement and authority boundary as any regulated artefact (Book 1’s stated defence). This page further recommends making data-pipeline repositories subject to controls 1–8 and flagging join-key and identifier changes for domain review. See data, API and integration.

Classify everything the assistant produces

Code is one artefact type among many. Write down, per estate, every type an assistant now produces, with an owner and a control point (Book 2 Ch 1 §7 lists the types; the owner and control-point columns, and the standing-context row, are this page’s recommendation):

Artefact typeOwnerControl point
Application codeProduct team / CODEOWNERSControls 1–8
Tests and evaluation casesProduct team; consumers for contract testsProvenance recorded; protected oracle
Infrastructure templatesPlatform teamPolicy-as-code checks, plan review
Data mappings and pipelinesData product ownerDictionary change control (above)
Migration scriptsProduct teamRehearsal plus named reviewer
API definitionsAPI ownerContract tests, consumer review
Documentation and runbooksService ownerReview against live behaviour
Change requestsChange ownerChange governance routing
Standing context, skills, promptsLayer ownerGoverned as policy change

Application regimes. Book 1 (Ch 15 §4.4) governs the portfolio under four regimes: bought, built, no-code/low-code and agent-created. No-code is where AI most easily produces production-affecting artefacts the SDLC pipeline never sees; register those artefacts in the application portfolio. Every agent-created digital asset inherits its wrangler’s accountability and the governance perimeter of the originating agent. A flow an agent generates is owned by that agent’s wrangler until it is formally transferred (accountability).

The wrangler loop and the harness

The wrangler works one pattern for every task: Define → Dispatch → Review & Merge (Book 2 Ch 14 §4.5; ADD proposal §4a.3). Define the work as a spec with constraints and acceptance criteria. Dispatch it to the agent or swarm, tracked as issues and pull requests so every action leaves a trail. Review and merge, or return it to Define with an adjusted spec.

The wrangler loop: define, dispatch, review and merge, with a named human at the accountability points while execution scales.

Source: The AI Delivery Factory, Chapter 14, Figure 14.1.

The harness around the model has three parts, each answering a failure mode:

Harness partWhat it doesAnswers
SubagentsSplit a large task into bounded pieces so no agent holds more scope than it can execute reliablyDrift
Review loopsOne agent critiques another’s output before it reaches the humanVolume, plausibility (filtering only; not a substitute for human review)
Verification passesRun tests and checks and feed failures back to the agentPlausibility

Issue-tracked dispatch is the universal form: a work item with an ID, an agent identity on the PR, and the wrangler as accountable human. As of mid-2026, per Book 2 Ch 14 §4.2–§4.4, Claude Code provides a plan mode for the plan-review pause, CLAUDE.md is its standing-context convention and AGENTS.md is the cross-tool equivalent [FACT-CHECK: confirm current Claude Code plan-mode behaviour and AGENTS.md governance against official documentation]. Build around the shape (work order in, agent plans/acts/observes, human reviews), not a product name.

One source of truth per artefact, and the auditor’s questions

A markdown chain arrives in a firm that already has a tracker, a requirements tool, a change system and an incident tool. Without a rule, the two copies drift and neither is evidence. Every artefact has exactly one declared source of truth and a two-way link to the other system (Book 2 Ch 15 §4.9). Book 2’s suggested split for a firm of Asset Manager X’s shape (composite, as of September 2026):

ArtefactSource of truth
Portfolio epics, priorities, funding, capacityTracker
intent.md, spec.md, plan.mdGit repository
Requirements under a mandated traceability regimeExisting requirements tool (markdown mirrors it)
Code, tests, review findings, release manifestGit and CI
Change approvals and release authorisationsChange-management system
Incidents and post-incident reviewsIncident tool, with the generated intent.md in Git

Enforce the linkage mechanically rather than asking for it: the work-item key goes in each markdown artefact’s front matter, in the branch name and in commit messages, and the work item holds the commit or PR reference. When the tracker is the authoritative copy, the agent loads the item when its session opens and records the outcome back before that session ends, so nobody has to re-key it.

The chain then answers an auditor’s seven questions mechanically (Book 2 Ch 15 §5.3):

Auditor asksAnswer lives in
Who asked for this change, and why?intent.md: author, history, epic link
Which policies applied; who resolved conflicts?spec.md: flagged concerns, skill versions in force
What was going to be built; who agreed?plan.md and its recorded approval
What was built and tested?Diff, test output, evaluation results on the PR
Who reviewed and approved it?Review findings, code-owner approval, branch-protection record
Who authorised production?Release manifest and production-gate log
What happened afterwards?Monitoring records, incidents, and the intent.md they generated

Each stage emits into the evidence record; the join keys session_id and change_id turn seven answers into one query. The change_id minted at stage 1 travels the whole chain.

Restart at the right depth

When work diverges, find the earliest incorrect artefact. Ask whether a competent agent reading the current spec would make the same mistake. If yes, revise intent/spec with its owner and invalidate downstream plans, code and tests. If no, keep the spec, discard the bad plan or branch, correct standing guidance or the execution constraint, and restart from there. Do not salvage a branch whose assumptions are no longer valid.

Record each restart: failed run ID, cause, affected artefacts, correction, rerun result and any guideline harvested. Measure guidelines harvested per restart, not restarts avoided. If source artefacts or test integrity cannot be established, stop promotion and route to the named owner. Never let an agent repair its own failing acceptance gate and count that run as a clean pass.

Close the loop

Monitor with deterministic rules. On a threshold breach, use the approved response rung: log, diagnose read-only, or propose a change for review. Add incident behaviour to the shared evaluation set. A monitoring finding becomes a bounded PR or a proposed intent.md that a human accepts; agents do not file their own work straight into the backlog.

Start with a baseline audit

Audit before you write policy (Book 1 Ch 15 §7.1). In the first week establish:

  • Assistant licences by team and repository.
  • Volume of AI-assisted PRs per repository over the previous four weeks.
  • Change in median time-to-review over the same period. (Book 2 Ch 1 §7 adds the useful split: plot high- and low-adoption teams’ review latency on one chart.)
  • CODEOWNERS state across the top twenty repositories: bus factor, last review date, CIF coverage.
  • Whether deployment identities are separated from human developer identities, repository by repository.

Then intervene in order: roll out the AI-era PR template; instrument automated gates against the four failure modes; commission the quarterly CODEOWNERS review across the CIF estate; commission the deployment-identity separation audit (Book 1 estimates six to twelve weeks). A smaller firm should pause new licence issuance until the PR template exists (Book 1 estimates two days for one engineer).

Ownership. Compliance maps the eight controls to the obligations that require or expect them and attests annually. Internal audit runs a half-yearly sample test of attribution: agents commit under their own identity, the wrangler of record is named, no agent service principal holds standing production access.

Failure modes to watch

FailureRecognise itRecover
Artefacts written after the factCommit timestamps on intent.md/spec.md are later than the code they claim to govern. Run this query monthly.Enforce order mechanically: no branch without an approved plan, no plan without a committed spec, no spec without an accepted intent.
Two sources of truth, no linkDelivery manager and wrangler give different answers about what a feature should doDeclare the source per artefact; enforce keys; same-session write-back.
Plan as scratch paperNo approved plan can be produced for a merged change; diff touches files the plan never namedCommit the plan, record the approval against a name, check diff-versus-plan in review.
Spec trusted on its ownNo spec-generated test loop, or the agent can edit the tests that judge itSpec generates tests; independent oracle; results fed back. Avoid over-speccing; iterate.
Restart treated as failureDivergent work salvaged under deadline; re-plans without spec amendmentsMake cheap restarts a designed feature; reward spec amendments.
Rule in the wrong layerA prohibited default slips through “because it was in the guidance”, or weekly exception requestsTag wall vs direction; supervisor test decides.
Agents filing their own workBacklog grows faster than anyone reads it; originator is a scriptA human accepts findings before they become work.
Two speeds as two departmentsSpecs written by people who never read state reports; spec amendments need cross-departmental meetingsKeep both cadences inside one product team; the wrangler who amends the spec sits with the intent owner. Book 2 cites SDC’s 1975 software factory, which failed when design was organisationally separated from construction.
AI reviewer replaces humanFewer requested changes, more post-merge defectsNon-blocking AI commenter; human on every merge.
Assistant rollout without CODEOWNERSOwners include leavers; bus factor of one on critical pathsQuarterly review; gate expansion on coverage.
Deployment identity used by an agent at runtimeAgent runs as the identity humans use for emergency production accessSeparate immediately: own principal, minimum role, time-bound, registered.

Acceptance and evidence

A pilot is ready to expand when an independent reviewer can follow the chain from accepted intent through plan, diff, tests with known provenance, evaluation, named approvals and deployed release, and can identify the actor (agent ID and human) at every boundary. Test at least one negative path in each class: stale spec, prohibited file write, new unregistered data connection, failed test, missing second reviewer on a CIF path, unhealthy release. Each must block or trigger the documented response. Verify rollback or disablement in a safe environment and keep the evidence.

Stage-level measures (Book 2 Ch 15 §5.4): elapsed time from first conversation to committed intent.md; number of spec.md commits dated after the first plan.md (requirements rework after build started); share of changes merging on the first implementation pass; time from monitoring breach to triaged item; falling count of review findings that cite skill-encoded policy. Add the AI-assisted-change ratio and review latency per repository (Book 2 Ch 14 §7). Keep them separate: fewer review minutes do not prove quality, and more agent commits do not prove delivery value. The factory-level scorecard is out of scope here; see running the factory.

Platform equivalents

As of May 2026, per Book 1 Ch 15 §4.5 [FACT-CHECK: product names and GA dates against current vendor documentation]:

ConcernMicrosoft (Book 1 primary)AWSGCP
AssistantGitHub Copilot EnterpriseAmazon Q DeveloperGemini Code Assist
Pipeline and security gatesGitHub Advanced Security (CodeQL, secret scanning, dependency review) on GitHub Actions or Azure DevOpsCodeBuild/CodePipeline; CodeArtifact for packagesCloud Build; Artifact Registry for packages
Agent identity (control 7)Entra Workload IdentitiesIAM Identity Center plus AgentCore IdentityWorkload identity federation
Deployment identity (control 8)OIDC federation from GitHub/Azure DevOps to AzureNot named by Book 1; it says the CI-to-cloud OIDC configuration is the same on every cloudNot named by Book 1 (as for AWS)
CODEOWNERS semanticsGitHub / Azure ReposRepository hostRepository host

Source lineage and current limits

The artefact chain, context artefacts, ADR/GIP split, skills/hooks rule, agent-identity position, source-of-truth table, auditor’s chain and anti-patterns are synthesised from The AI Delivery Factory (Book 2), Chapters 1, 3, 5, 14, 15 and 28. The four failure modes, eight controls, CODEOWNERS rule, AI-reviewer anti-pattern, data-drift mechanism, four regimes and baseline audit come from Building Organizations for the Age of AI (Book 1), Chapter 15 and Appendix F. Human-review lanes come from Deploying Claude Safely (Book 3), Chapter 13. Test provenance, the trust order, the reviewer template and the data-connection check come from Everything Is Green (Book 09, Draft 1, 14 November 2026), Chapters 2, 4, 5, 6 and 8, a narrative revision that does not replace Book 2’s technical treatment. Book 1 and Book 2 describe the same four failure modes; this page uses Book 1’s control set and Book 2’s techniques as two layers of one table. Bank A and Asset Manager X are composites, not customer evidence. Gates and acceptance checks are recommendations, not claims of regulatory sufficiency. This page is a draft.

Source material

  • Book 1, Chapter 15: SDLC in the Age of AI (§4.1–§4.4 failure modes, drift and four regimes; §5.1 eight SDLC controls; §5.3 checklist; §7 Monday-morning audit; §8 anti-patterns)
  • Book 1, Appendix F: SDLC Component and Capability Catalogues (§F.6 mapping to the eight controls)
  • Book 2, Chapter 1: The Day the Review Queue Broke (§7 classifying what the assistant touches)
  • Book 2, Chapter 3: Why Craft Alone No Longer Scales (§6 judgement dressed as operation)
  • Book 2, Chapter 5: Bills of Material and Recipes (§4.1 three context artefacts; §7 the standing-instruction file)
  • Book 2, Chapter 14: When AI Writes the Code (§3–§4.5 failure modes, spec, standing context, harness; §7; §8)
  • Book 2, Chapter 15: The SDLC at Agent Speed (§4.6 ADR/GIP, skills advise hooks enforce; §4.8 agent identity; §4.9 one source of truth; §5.3 auditor's chain; §5.4 stage metrics; §8 anti-patterns)
  • Book 2, Chapter 28: Mary's Migration, Rewritten (§4 the recipe; §6 the rejected script; §8)
  • Book 3, Chapter 13: Wranglers, Product Teams and RACI (§4.3 where the human stays in the loop)
  • Book 09, Chapter 2: The Exam Nobody Announced (domain review questions); Chapter 4: Right About the Code, Wrong About the Product (test provenance, three files); Chapter 5: Whose Name Goes Here (reviewer template, data-connection check); Chapter 6: Two Speeds; Chapter 8: The Number That Was Too Good (Draft 1, composite narrative)
  • ADD proposal, Strategic Brief §4a.3 Wrangler Control Plane and §4a.6 AI Skills Library

← All AI Delivery Factory guidance

On this page

  1. What AI changes in the SDLC: four amplified failure modes
  2. The stages and their gates
    1. Definition of ready for an agent
    2. Enforce the chain at commit boundaries
  3. Give the agent the right context
    1. Three context artefacts
    2. Standing context files: owned like code, layered, audited
    3. Walls and directions: ADRs, GIPs, skills and hooks
    4. Skills library lifecycle
  4. The recipe decides the shape; judgement stays with people
  5. Test provenance and the trust order
  6. The eight SDLC controls for AI-assisted code
    1. CODEOWNERS as a regulated document
    2. An AI reviewer must not replace human review
    3. Human-review lanes
    4. Reviewer template and domain questions
  7. Identity and data connections at commit time
  8. SDLC drift becomes data drift
  9. Classify everything the assistant produces
  10. The wrangler loop and the harness
  11. One source of truth per artefact, and the auditor’s questions
  12. Restart at the right depth
  13. Close the loop
  14. Start with a baseline audit
  15. Failure modes to watch
  16. Acceptance and evidence
  17. Platform equivalents
  18. Source lineage and current limits

All pages in Deliver changes →