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
- Section
- Deliver changes
- 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
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

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 mode | What you see | Technique that answers it (Book 2) | Book 1 controls (below) |
|---|---|---|---|
| Volume: more change arrives than reviewers can absorb | Review latency climbs while headcount stays flat; one-reviewer, quick-look merges; quality loss shows up as incidents weeks later | Risk-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 correct | Idiomatic, green, coherent changes that solve a slightly different problem | Spec-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 architecture | Three patterns for the same concern across services; unsanctioned libraries; data joins that silently change meaning | Standing context, ADRs enforced as hooks/CI, recipe-bound workspaces | 5, 6 |
| Attribution: authorship and accountability blur | Commits under a human’s account that the human never read; anonymous bot committers; no on-call owner for an agent | Agent identity carried into the evidence record, with a named wrangler as accountable human | 7, 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.
| Stage | Committed artefact | Human decision or deterministic control |
|---|---|---|
| Plan the work | intent.md: problem, outcome, users and constraints in the originator’s words | Product owner accepts or rejects the intent; risk tier and data class are assigned. |
| Design | spec.md: testable requirements and design | Product owner resolves concerns with policy owners. Skills advise during drafting. |
| Build | plan.md, then the code diff | The agent proposes files, order, tests and risks. Its wrangler approves the plan before code is written. |
| Test | Test runs and evaluation results | Deterministic checks run; the agent cannot change the tests judging its own fix. |
| Deploy | Pull request, review findings and release manifest | Code-owner review and production authorisation happen at their gates. |
| Maintain | Monitoring and incident records | Deterministic 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.

The committed artefact chain. Source: The AI Delivery Factory, Chapter 15, Figure 15.1.
| Boundary | Required check before proceeding |
|---|---|
| Intent → spec | Product owner accepted outcome, scope and measurable acceptance; risk/data classification and named owner present. |
| Spec → plan | Spec current and versioned; plan names affected files/services, tests, assumptions, risks and out-of-scope work; wrangler accepts it. |
| Plan → diff | Agent identity and permissions bounded; writes restricted to the authorised workspace; protected paths, credential material and new data connections checked deterministically. |
| Diff → PR | Automated gates pass (control 1); generated test changes are visible and reviewed separately from production changes; PR template complete (control 2). |
| PR → release | Independent human review, policy gates, evaluation and release authorisation recorded against the same change and artefact versions. |
| Release → operation | Deployed 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):
| Artefact | Question it answers | Typical form | Owner |
|---|---|---|---|
| Standing instruction file | How do we build here? Sanctioned frameworks, identity wiring, logging, “never do” rules | CLAUDE.md, AGENTS.md or equivalent at the repository root | Recommended: platform team (firm layer), domain/architecture lead (domain layer), repo owner (repo layer) |
| Specification | Build this. What the product is and what this change must do | spec.md in the repository, beside a current product record (BOM) | Product owner |
| Recipe | Build it this way and no other. The approved assembly, release and evidence pattern | Machine-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):
- 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.
- 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.
- 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.
- 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.
- 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).
- 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:
| Instrument | Meaning | Implemented as | When broken |
|---|---|---|---|
| ADR (Architectural Decision Record) | A wall: a settled decision you build inside | Hook, permission rule or CI check when it must hold | Blocked. A breach is a defect or incident. |
| GIP (global internal practice) | A direction: followed most of the time, breakable on purpose | Skill (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.

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):
| Trust | Test source | How to obtain it (this page’s recommendation) |
|---|---|---|
| 1 (highest) | Written or approved by someone who knows the product as it is now | Product-owner or domain-expert approved cases; golden records under a named expert |
| 2 | Owned by a downstream consumer | Register consumers in the product record; the pipeline runs consumers’ contract checks against the change before human review |
| 3 | Drawn from a source other than the change’s own spec | Tests derived from the current product record, characterisation tests of live behaviour, incident-derived evaluation cases |
| Lowest | Generated with the change from the same spec | Useful 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.
| # | Mode | Control | Implementation detail | Book 1 label | Evidence |
|---|---|---|---|---|---|
| 1 | Volume | Automated review gates pass before a human is asked to look | Lint, security scan, architecture conformance, test-coverage delta as required status checks | [REC] | Check results bound to the PR and commit |
| 2 | Volume | AI-era PR template with mandatory fields | AI used, prompt, manual verification, coverage delta, CIF flag (plus the reviewer fields below) | [REC] | Template fields captured in the PR record |
| 3 | Plausibility | Two human reviewers for any PR touching a critical or important function (CIF), regardless of size | Path-based CODEOWNERS rules plus branch protection requiring two approvals on CIF paths | [EXP] | Two named approvals in the merge record |
| 4 | Plausibility | Mandatory dynamic analysis (DAST) on any change touching authentication, authorisation, payment flows or customer data | Path/label triggers that make the DAST job required for those areas | [REQ] | DAST report attached to the release |
| 5 | Drift | Architecture-conformance rules as code at PR time | ArchUnit-style fitness functions, not architecture-by-slide | [PREF] | Fitness-function results per PR |
| 6 | Drift | Library and framework choices pinned in a per-repository policy file the assistant reads as context | Allow-list file in the repo, referenced from standing context and enforced by dependency review | [PREF] | Dependency-review results; policy-file version |
| 7 | Attribution | Agents commit under their own identity; the wrangler is the human of record | Registered workload identity per agent; never a human’s token or an anonymous bot | [REQ] | Agent ID and wrangler in the commit/evidence record |
| 8 | Attribution | Deployment identity separate from human developer identity; OIDC federation only | No 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.

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):
| Field | Reviewer records |
|---|---|
read_against_plan | Confirms the change was read against its approved plan.md, not only against itself; diff touches no files the plan did not name. |
test_provenance | Where the tests came from; states explicitly if they came only from the agent. |
first_thing_to_check | In the reviewer’s own words, the one thing they would check first if this change failed. |
| Domain questions | A 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_idtoexternal_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 type | Owner | Control point |
|---|---|---|
| Application code | Product team / CODEOWNERS | Controls 1–8 |
| Tests and evaluation cases | Product team; consumers for contract tests | Provenance recorded; protected oracle |
| Infrastructure templates | Platform team | Policy-as-code checks, plan review |
| Data mappings and pipelines | Data product owner | Dictionary change control (above) |
| Migration scripts | Product team | Rehearsal plus named reviewer |
| API definitions | API owner | Contract tests, consumer review |
| Documentation and runbooks | Service owner | Review against live behaviour |
| Change requests | Change owner | Change governance routing |
| Standing context, skills, prompts | Layer owner | Governed 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.

Source: The AI Delivery Factory, Chapter 14, Figure 14.1.
The harness around the model has three parts, each answering a failure mode:
| Harness part | What it does | Answers |
|---|---|---|
| Subagents | Split a large task into bounded pieces so no agent holds more scope than it can execute reliably | Drift |
| Review loops | One agent critiques another’s output before it reaches the human | Volume, plausibility (filtering only; not a substitute for human review) |
| Verification passes | Run tests and checks and feed failures back to the agent | Plausibility |
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):
| Artefact | Source of truth |
|---|---|
| Portfolio epics, priorities, funding, capacity | Tracker |
intent.md, spec.md, plan.md | Git repository |
| Requirements under a mandated traceability regime | Existing requirements tool (markdown mirrors it) |
| Code, tests, review findings, release manifest | Git and CI |
| Change approvals and release authorisations | Change-management system |
| Incidents and post-incident reviews | Incident 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 asks | Answer 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
| Failure | Recognise it | Recover |
|---|---|---|
| Artefacts written after the fact | Commit 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 link | Delivery manager and wrangler give different answers about what a feature should do | Declare the source per artefact; enforce keys; same-session write-back. |
| Plan as scratch paper | No approved plan can be produced for a merged change; diff touches files the plan never named | Commit the plan, record the approval against a name, check diff-versus-plan in review. |
| Spec trusted on its own | No spec-generated test loop, or the agent can edit the tests that judge it | Spec generates tests; independent oracle; results fed back. Avoid over-speccing; iterate. |
| Restart treated as failure | Divergent work salvaged under deadline; re-plans without spec amendments | Make cheap restarts a designed feature; reward spec amendments. |
| Rule in the wrong layer | A prohibited default slips through “because it was in the guidance”, or weekly exception requests | Tag wall vs direction; supervisor test decides. |
| Agents filing their own work | Backlog grows faster than anyone reads it; originator is a script | A human accepts findings before they become work. |
| Two speeds as two departments | Specs written by people who never read state reports; spec amendments need cross-departmental meetings | Keep 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 human | Fewer requested changes, more post-merge defects | Non-blocking AI commenter; human on every merge. |
| Assistant rollout without CODEOWNERS | Owners include leavers; bus factor of one on critical paths | Quarterly review; gate expansion on coverage. |
| Deployment identity used by an agent at runtime | Agent runs as the identity humans use for emergency production access | Separate 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]:
| Concern | Microsoft (Book 1 primary) | AWS | GCP |
|---|---|---|---|
| Assistant | GitHub Copilot Enterprise | Amazon Q Developer | Gemini Code Assist |
| Pipeline and security gates | GitHub Advanced Security (CodeQL, secret scanning, dependency review) on GitHub Actions or Azure DevOps | CodeBuild/CodePipeline; CodeArtifact for packages | Cloud Build; Artifact Registry for packages |
| Agent identity (control 7) | Entra Workload Identities | IAM Identity Center plus AgentCore Identity | Workload identity federation |
| Deployment identity (control 8) | OIDC federation from GitHub/Azure DevOps to Azure | Not named by Book 1; it says the CI-to-cloud OIDC configuration is the same on every cloud | Not named by Book 1 (as for AWS) |
| CODEOWNERS semantics | GitHub / Azure Repos | Repository host | Repository 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
Related guidance
-
The AI Delivery Factory: Operating ModelThe factory's six connected parts, the control gap it closes, the handover curve that governs what agents may take over, and how to start one without rebuilding your tooling. -
Release Engineering for Agent-Written ChangeMove agent-speed change into production through five evidence-emitting stations: one change type per change, a reversal decided at authoring, a valid Deployer Manifest, a gateway that cannot be bypassed, hard health gates and at-most-once rollback. -
Change Governance for Agent-Enabled DeliveryRoute agent-speed change by risk without losing the approver: control values that always reach a person, a routing gate that reads the right signals, autonomy earned per change family, a Virtual CAB that prepares a complete dossier, and three bodies with defined escalation. -
Build a Living Product Bill of Material and RecipeDescribe what an AI product contains and how the firm builds it in one versioned specification shared by pipelines, agents and assurance teams, including the classification line, readiness grades and reuse generations. -
Assess Agent Readiness Across the EstateCheck the estate's control foundations, grade the stations a change must cross on evidence, route work by the weakest station, fund readiness worst-first with a stated split, and make bought products machine-operable at renewal. -
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
Build the Standard Application FoundationRun the shared identity, telemetry, deployment, data and AI capabilities as a funded product that humans and agents both start from, with a contract, evidence-computed trust, a cheap promotion boundary and reuse measured by consumption. -
Accountability and OwnershipHold provenance and accountability apart on purpose: four named accountabilities per product, a human owner for every agent change, seven named seats, a signed Build/Run RACI and a first-line/second-line boundary that survives consolidation. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Bounded-Agent PatternA class 3 agent lets a model choose the next step, but only inside a registered, validated and enforced envelope of Mandate, Means, Memory and Monitoring.