How we work · Engineering

The Four Handoffs, for engineering leaders

What changes in your engineering team at each of the Four Handoffs, the points where work passes from one person or team to the next and where the gains from AI leak out.

What you get

What you take to your board

Once the first change we agree with you is live, you and your CEO take your board a readout, built with us from your own systems, that answers three questions about whether AI is paying off. The work is aimed at improving all three, and the readout shows how far each one moved.

  • Are we building what the business needs? Progress on your top two or three goals against their baselines, how much of what engineering commits to gets delivered, and how much engineering time goes to each goal and to new capabilities.
  • Is delivery faster without getting riskier? Time from idea to customer, how long work waits on review, how often a change fails in production and how many deployments are unplanned fixes, from your ticket, code, deploy and incident history.
  • Is the AI spend paying back? AI spend and use by team, set beside the first two answers so your board can weigh the cost against the results, with any self-reported time savings checked against what actually shipped.

Behind those answers, your team runs the practices for each of the Four Handoffs described below, each with a measure. Everything below is what we propose, and you decide what becomes a rule.

Intent

Goals your engineers can see

Engineers and agents can build the wrong thing very fast when the goals get lost between the leadership team and the people building. So your company’s top two or three goals, each with a baseline, sit where every engineer and agent can see them. Each piece of planned work names the goal it serves, and you can show your CEO at any point how much of engineering’s time is going to each goal.

Changes above a size your team agrees start from a short spec that says what the change is for and how it will be checked, so an agent builds what was asked rather than what it guessed.

Unless you already have a spec tool, we use OpenSpec, an open-source tool we run on our own builds, which keeps specs as plain files beside your code. Our template and CI check, both open source, tie each spec to the goal it serves and flag changes above that size that have none. [See one change go through them](#one-change).

Ownership

Decisions with a named owner

Work waits when nobody is sure who can say yes. Your leadership team agrees who makes which calls, and wherever work stalls between two teams, we work out with both who owns it and how requests cross over. Decisions about AI and architecture go in short architecture decision records, as Michael Nygard described them, so the next person can see why they were made, and your team revisits who makes which calls after any reorg.

A status in your ticket system marks work that’s waiting on a decision, so you can see how long it waits and where.

Review

Code a person can defend

When agents turn out code faster than anyone can review it, it either piles up waiting or gets approved unread. We propose that each team agree how big a single change can be, so a review stays readable, and how soon a review gets picked up, as a working agreement rather than a target. The engineer who asked an agent for a change owns it and answers reviewers’ questions on any line, and someone else approves it. Until the readout, we propose that AI review is a first pass and never the approver.

How closely a change is checked depends on what it could break. We propose two approvers, one of them a code owner, on code that touches money, login, permissions or migrations. On the parts of your code you name as business-critical, agents change nothing until tests lock in what that code does today, what Michael Feathers calls characterization tests. Your engineers keep working on that code by hand in the meantime, the tests go in first where agents will work soonest, and once they’re in, agents work there under the same review as everything else.

Where customers act on a number your system calculates, tests check it against answers worked out independently of the system, never against the system’s own output or an agent’s word that it checked.

You can see how long a change waits for review, read beside its size, and how often a change big enough to need a spec is approved within minutes of being opened, a sign nobody really read it.

Learning

What one engineer learns, the team keeps

The gains from AI stay with one person unless what they learn reaches the team. The team’s agent settings, prompts and rules live in your repository, reviewed like code and kept short, so a lesson one engineer turns into a setting reaches the whole team. Each business-critical part of the code gets a short page for agents covering what they can’t work out from the code itself, drafted by an agent and corrected by the engineer who knows it.

Once a week, in the Weekly Replay, the team spends thirty minutes on one real agent session, including where it went wrong and how that was caught, and usually agrees one change to its shared settings. A mistake that keeps coming back becomes a test or a check wherever it can. You can see, by team, how often agents repeat a mistake the team has already guarded against, and that number should fall as each lesson spreads.

Guardrails around all four

The guardrails keep an agent’s mistake small and reversible. We keep agents away from production and your secrets, and anything that can’t be undone, like a migration or a message to customers, waits for a person to approve the exact plan.

Code from agents goes to production through your pipeline, like any other change, and we won’t add a language model to the live path that charges a customer, quotes a price, grants access or signs someone in.

You can see how often changes fail in production and how many deployments are unplanned fixes (DORA’s change fail rate and deployment rework rate), including how many trace back to changes the pull request marks as made by an agent.

See it work

One change, from spec to production

Here is one change on its way from your goals to release, starting with the install of our open-source kit, handoffs-spec-check, the template and CI check described under Intent. The example is the one in the kit’s tests, a one-line change to the code that totals invoices, planned as part of a CSV export of the monthly revenue report.

The kit’s test script wrote the example’s files, and every code block is copied from the kit, its example or its real output, with some lines left out. The kit covers the spec and the check, and review and release run through your own process, as the sections above propose.

Your goals live in your repository, under your approval

What the agent does: From the first spec on, agents cite one of your goals by its ID, and the kit’s guidance tells them to ask rather than invent one. A spec whose goal isn’t on your list gets flagged.

What a person decides: You approve the install and put in the goals you and your CEO agreed. You, or an owner you name, become code owner of the check’s settings, the goals and agent files such as CLAUDE.md.

Install, from the README

npm install --save-dev --save-exact @fission-ai/[email protected]
npx openspec config set telemetry.enabled false
npx openspec init
./install.sh /path/to/your-repo
npx openspec schema validate handoffs

kit/.github/CODEOWNERS.example, what branch protection needs

# Branch protection on the default branch must also have:
#   - Require a pull request before merging
#   - Require review from Code Owners
#   - Dismiss stale pull request approvals when new commits are pushed
#   - Require approval of the most recent reviewable push

openspec/goals.md in the example

# Company goals

- G-101: Cut time from signup to first invoice to under one day
- G-102: Keep monthly billing errors at zero

README: Install · kit/.github/CODEOWNERS.example · kit/openspec/config.yaml

An agent writes the spec before any code

What the agent does: Runs OpenSpec’s propose workflow, which is told to stop before any code. The spec it drafts names the test behind each scenario in verification.md and, where money moves, a separate calculation that reaches the number another way.

What a person decides: The engineer who asked for the change reads the spec, corrects it and decides when building starts.

In the example: The proposal cites goal G-102 and ticket FIN-482, and the first version of verification.md lists the separate calculation as n/a.

The proposal template, kit/openspec/schemas/handoffs/templates/proposal.md

## Goal

**Goal:** <GOAL-ID> - <one line: what moves for the company>

## Ticket

**Ticket:** <tracker ID or URL>

A scenario from the example

#### Scenario: Export a month with invoices
- **WHEN** a finance user exports a month that has invoices
- **THEN** the CSV has one row per invoice and a total row

kit/openspec/schemas/handoffs/schema.yaml · OpenSpec

The build follows the spec

What the agent does: Runs OpenSpec’s apply workflow and works through the tasks. The kit tells it to give each test in verification.md its own task, beside the work that test proves.

What a person decides: Where [Review](#review) keeps agents out, the engineer makes the change by hand. Either way, they open the pull request, marked if an agent wrote the change.

In the example: Here the change is one line in src/billing/invoice.js.

kit/openspec/config.yaml, guidance the agent reads

rules:
  tasks:
    - Each test named in verification.md gets a task in the group whose work it proves

kit/openspec/config.yaml · An engineer running AI agents is managing a team

A missing piece gets flagged when the pull request opens

What the check does: A plain script with no AI in it, which makes no external API calls; the action only downloads Node.js and the pinned OpenSpec packages. It validates the spec with OpenSpec, then reads the proposal and verification.md.

What a person decides: In warn mode, the default, a flag is advice. It fails the check only once you turn on block mode with your name and date, and it holds a merge only if you make the check required.

In the example: The change touches billing, which the default settings say always needs a spec, however small the change, and verification.md still lists the separate calculation as n/a.

What it runs on each change, from the README

openspec validate <name> --type change --strict

The check’s summary

Spec check: FLAGGED (warn mode, not blocking)

Bigger than small because: touches paths that always need a spec: src/billing/invoice.js
Change add-report-export (modified in this pull request): has problems, listed below

To fix:
- add-report-export: this pull request touches money paths; verification.md must name at least one separate calculation (values starting with no, none, n/a, not applicable or nope do not count)

The check, spec-check.mjs · README: Warn and block · The example, test/run-tests.sh

Your reviewers still decide

What the agent does: Fills in the separate calculation, and the check passes. The check doesn’t confirm that the named tests exist or pass, so your reviewers and your test suite still have to.

What a person decides: Your reviewers decide whether the change is right and whether that calculation really is independent of the code it checks. On billing code, the approvals [Review](#review) proposes apply.

verification.md, the row that fixed it

| Scenario | Test that proves it | Separate calculation |
|---|---|---|
| Export a month with invoices | `src/app/report.test.js` > exports one row per invoice | ledger total for the month equals CSV total |

The check’s summary

Spec check: PASSED

Bigger than small because: touches paths that always need a spec: src/billing/invoice.js
Change add-report-export (modified in this pull request): validates; has Goal, Ticket, Files at Risk, verification.md covering 2 scenarios

This check confirms the spec exists and is filled in. It does not confirm the spec is right; review does that.

README: What it can’t stop · How AI-written code gets proven before it counts · Does your plan match your code?

Release stays with your team

What the agent does: Agents have no part in the release, as [the guardrails](#guardrails) set out. Once the change is merged, an agent runs OpenSpec’s archive workflow, which folds its scenarios into the specs that describe your system.

What a person decides: Your team decides when the change goes out.

The follow-up the schema suggests at the end of the tasks

## Workflow follow-up

- Archive the change after the project's review requirements are satisfied.

kit/openspec/schemas/handoffs/schema.yaml

A lesson goes into the team’s agent settings

What the check does: Lists changes to agent files such as CLAUDE.md for their code owner, without failing the pull request.

What a person decides: When a review turns up something every agent should know, the team agrees the fix, often in the Weekly Replay, and you or the owner you name approve it.

The check’s note to the reviewer

For the reviewer (does not affect the result):
- agent instructions changed; code owner should review: CLAUDE.md

kit/.github/spec-check.jsonc · When AI makes a few engineers faster

The kit ships as a GitHub Action, and its tests, which run on every push, call the same script from the command line. The code and the list of what it can’t stop are on GitHub.

Working together

The three steps

We agree the measures with you and put the guardrails in place first. After that, the order follows whatever the early numbers and your team say is costing you the most.

  • Find what pays: the starting point. You know where work waits and which AI tools your engineers use, each of your top goals has a baseline, each pull request marks whether an agent made the change, and the delivery numbers have a starting point from your history, with estimates where that history is thin.
  • Find what pays: the costliest handoff. Work starts there, then on the others, with the Weekly Replay under way and tests going in on the business-critical code.
  • Build it in. The numbers show how far things have moved at each handoff, from time waiting on decisions and review to how often changes fail. Agents work on the business-critical code once its tests are in, any numbers customers act on are checked against answers worked out independently, and we build the readout with you.

Keep it running: if you choose to keep going after the readout, we can add agents that carry one long task over weeks, like a migration, inside the same guardrails.

Short answers

  • Where does the work live? In your repositories and systems, under your access rules.
  • Can AI agents touch production? We keep them away from it, as the guardrails describe.
  • Which AI vendors see our code? For the work we do together, only the ones you approve, on the plans and data-retention terms you choose. At the start we list the AI tools your engineers already use, so you can see which vendors see your code today.
  • Who owns what we build? You do, and our agreement says so.
  • Who runs it after the readout? Your team runs it from the start, with us alongside, and whether we keep going is your and your CEO’s choice.
  • Do we need OpenSpec? No. Specs are plain files, and if you already use another spec tool, we use yours. Our open-source template and check are built for OpenSpec, and we adapt the check to the spec tool you use.

What stays your call

You decide which code counts as business-critical, when AI can approve anything and what becomes a rule. We build the readout with you, and you and your CEO take it to your board. Every number in it is marked as measured, estimated with a range, or pending, and the readout says what it didn’t check.

Our founder, Jeremy Brooks, facilitates and works alongside your engineers, with our senior builders joining when the work needs them. Every prompt, rule and agent setting we create lives in your repository and belongs to your company. The business side of the method is on How we work, and if your CEO sent you this page, we’d like to talk with you too. Before we talk, look at your last ten changes and note how big each one was and how long it waited for review, then book thirty minutes and bring what you found.