Method · Agent-assisted delivery

Agent-assisted delivery, constrained by the spec

We use supervised coding agents to deliver like a larger team. They build only from tasks in the spec, a senior engineer reviews every change before it merges, and only tools the client approves in writing ever see the client's code.

Updated 22 November 2026

What agent-assisted delivery means here

Agent-assisted delivery means coding agents write part of the code, inside rules that a senior engineer enforces. The agent receives one task from the spec, the acceptance criteria it must satisfy and the relevant part of the plan. It proposes a change. The change merges only after it passes every quality gate and a senior review.

This is different from “AI-generated code”. Code an agent produces without a precise target is plausible rather than correct: it looks right and fails at the edges. The spec gives the agent a precise target, and the review checks the result against that same target. The agent adds speed. The spec and the reviewer supply the judgement.

Why agents need a spec

Agents build well when the task is precise and badly when it is vague. A spec with Given/When/Then criteria, listed states and a data map gives an agent exactly what it lacks: a definition of done. Without one, an agent fills the gaps with guesses, and nobody can tell which parts are guesses.

That is why we never point an agent at a ticket like “add a spending limit”. The agent receives a task like this:

## Task T-3 · Pending state and 24 h cool-down banner

Satisfies: AC-3 (spec: spending-limit v1.2)
Plan: components › LimitBanner · state › server-owned, pending until confirmed
Constitution: accessibility (announce state changes), performance (no layout shift)

Done when:
- AC-3 tests pass (limits.test.ts, account.spec.ts)
- No new storage keys or third-party requests
- axe reports no violations on /account

The task names its criteria, the files that test them and the rules it inherits. An agent working from it has no room to invent scope.

How a change moves from task to merge

Every change follows the same path, whether a person or an agent wrote it. The task is assigned, the code is proposed as a pull request, the automated gates run, and a senior engineer reviews it. Only then does it merge. No step is skipped for agent-written code, and none is added that slows human code.

  1. Task. Picked from the task list. It links to its acceptance criteria.
  2. Build. An agent or an engineer writes the change on its own branch.
  3. Gates. CI runs the criteria’s tests, security, privacy, accessibility and performance checks. See quality gates.
  4. Review. A senior engineer reads the diff against the task and its criteria.
  5. Merge. Only when every gate passes and the review approves.

Several agents can work in parallel on independent tasks. That is where the speed comes from: small tasks with clear boundaries can be built at the same time, and each is checked on its own.

What the senior review checks

The review checks what automated gates cannot: whether the change does what the criterion means, not only what its test checks. The reviewer reads the diff against the task, looks for behaviour the spec did not ask for, and checks that the code fits the plan’s architecture and will stay maintainable.

The reviewer asks Why it matters
Does the change satisfy the criterion’s intent, not just its test? A test can pass for the wrong reason
Does it add anything the spec did not ask for? Unasked-for behaviour is unpriced scope and untested risk
Does it follow the plan’s boundaries and decisions? Architecture erodes one shortcut at a time
Is it code a person can maintain? The client’s team inherits it
Are there edge cases the criteria missed? If so, we propose a spec delta rather than patch silently

The reviewer is never the author of the change, and never the person who operated the agent that wrote it. When a review finds a gap in the spec itself, the fix starts with the spec, not the code.

Which tools touch your code

Only coding tools the client approves in writing may access the client’s code or data. We list the tools in the Statement of Work before the build starts. If a tool is added later, it needs a new written approval first. We do not use tools whose terms allow training on the inputs we send.

The client’s code and data are never used to train any model. This is a contract term in our Build and Retainer engagements, not a preference. Confidential material stays in environments the client provides or approves, and nothing is pasted into a tool outside that list.

What stays human

People decide scope, architecture and acceptance. Agents do not write specs on their own, approve their own changes, change the constitution or decide what “done” means. Those decisions stay with the client and with our senior engineers, and they are recorded in the spec pack where anyone can read them.

Agents are also not used where the judgement is the work: threat modelling, accessibility review of new interaction patterns, and copy for errors and sensitive states. A senior engineer writes these, or reviews them line by line.

When an agent gets it wrong

An agent’s change fails the same way a person’s does: a gate goes red or the review rejects it. The change goes back with the failing criterion named, and it is fixed or rewritten before it can merge. Nothing an agent produces reaches the main branch on the strength of looking plausible.

We also learn from the failures. When agents repeatedly miss the same kind of behaviour, the usual cause is a spec that leaves it implicit. The fix is to make it explicit, as a new criterion or a sharper rule in the constitution. Over a project, the spec gets more precise, and agent output gets more reliable with it.

What you get from it

You get more delivered each week without lowering the bar. Every change is traced to a criterion, checked by the same gates, reviewed by a senior engineer and listed in the trace report at release. The code you receive is held to the same standard whoever, or whatever, typed it.

You are also not tied to our tools. The spec pack, the tests and the reports are plain files that work with Claude Code, Cursor, Copilot, Gemini CLI or no agent at all. If your team takes over, it inherits a codebase and a spec, not a dependency on how we worked.

Ask a question first

A private conversation on a company messenger. No forms, no tracking.

Message us