> /materialize ../my-project

Agents forget. Repos remember.

Own the agent team that builds your way.

Where do you start from?

Quick show of hands

  • Autocomplete and chat in the IDE
  • An agent in the repository e.g. Claude Code with a CLAUDE.md
  • An agent team e.g. subagents, skills, hooks

Heard around the industry

Sound familiar?

  • It is almost right, so I check everything
  • It has no idea what the product requires
  • It has never seen the system design
  • It ignores our team's norms
  • It comments every line
  • It takes the joy out of programming

What's in it for you

An agent team, with you on the loop

The promise

  • Works out with you what to build requirements and design, in dialogue
  • Builds it largely on its own spec-driven, tests first, domain-driven
  • Follows your rules every change reviewed to your written bar
  • Hands you code, tests, and specs reviewed and graded before it reaches you

The reality, measured

  • About $5 a feature one slice, on an eval bench
  • Under half an hour, unattended request in, reviewed change out
  • On the loop, not out of it you decide requirements and design; you merge
  • In use on more than ten projects the figures above come from one benchmark project

What you take from this talk. How such a team is designed and built, step by step.

Portrait of Bernhard Woditschka

Bernhard Woditschka

Principal Software Engineer · Developing software is my passion.

  • Simple and elegant solutions
  • Small teams that own what they build
  • Ship early and often, automate everything
  • Always learning, always sharing
  • AI changes how we will work
  • Let's understand it to own it

Where the human sits

The same loops, a different seat

Four seats

  • Human loop colleagues share the steps
  • Human loop, assisted you do every step, an assistant helps
  • Human in the loop agents do the steps; you review and hand over
  • Human on the loop you at the start and at the end; the team asks when stuck

One workflow

A lane of seven green people above a team's workflow, one over each step. The workflow runs left to right: a feature request pill, then requirements, system design, coding, review code, and judge code, then a merge pill. Four nested loop bands named TDD, review, slice, and codebase hold the steps. Dashed accent return arrows carry consultation and rework. The same workflow and loops. In the lane above, a green person stands over the request and the merge; over each of the five steps a green person stands above a green box labeled assistant. The same workflow and loops. In the lane above, a green agent box sits over each of the five steps. A green person stands over the request, requirements, system design, review code, and the merge; no person over coding or judge code. The same workflow and loops. In the lane above, a green agent box sits over each of the five steps. A person stands over the request, requirements, system design, and the merge; no person over coding, review code, or judge code.

Prompting

What stays with you

my-service/
├── src/
└── tests/
  • Human loop, assisted
  • Re-explain the conventions
  • Spell out every step yourself
  • Re-explain the product
  • Review everything yourself
  • Route between the steps

A rules file

Conventions stick.

my-service/
├── CLAUDE.md        build commands, conventions
├── src/
└── tests/
  • Human loop, assisted
  • Re-explain the conventions
  • Spell out every step yourself
  • Re-explain the product
  • Review everything yourself
  • Route between the steps

Then skills

A skill remembers how.

my-service/
├── CLAUDE.md
├── .claude/
│   └── skills/          how to test, review, ship
├── src/
└── tests/
  • Human loop, assisted
  • Re-explain the conventions
  • Spell out every step yourself
  • Re-explain the product
  • Review everything yourself
  • Route between the steps

Living specs

Specs remember what agents forget.

my-service/
├── CLAUDE.md
├── .claude/
│   └── skills/
├── docs/
│   ├── prd.md           what to build
│   ├── system-design.md how it is structured
│   └── adr/             why it won
├── src/
└── tests/
  • Human in the loop
  • Re-explain the conventions
  • Spell out every step yourself
  • Re-explain the product
  • Review everything yourself
  • Route between the steps

A team of experts

Fresh eyes on every change.

my-service/
├── CLAUDE.md
├── .claude/
│   ├── skills/
│   ├── agents/          requirements, design, review
│   └── hooks/           what a script can enforce
├── docs/
│   ├── prd.md
│   ├── system-design.md
│   └── adr/
├── src/
└── tests/
  • Human in the loop
  • Re-explain the conventions
  • Spell out every step yourself
  • Re-explain the product
  • Review everything yourself
  • Route between the steps

Automatic routing

Handoffs route themselves.

my-service/
├── CLAUDE.md
├── .claude/
│   ├── skills/
│   ├── agents/
│   └── hooks/
├── docs/
│   ├── prd.md
│   ├── system-design.md
│   └── adr/
├── .scratch/
│   └── handoff.jsonl    a script picks the next hop
├── src/
└── tests/
  • Human on the loop
  • Re-explain the conventions
  • Spell out every step yourself
  • Re-explain the product
  • Review everything yourself
  • Route between the steps

The theorem

What a good team knows by heart,
an agent team needs in writing.

And once it is written, the humans benefit too.

The theorem

What a good team does by habit,
an agent team needs in code.

And once it is in code, the humans benefit too.

A bug report in. A reviewed fix out.

Eval task owners-page-param, harness v0.4.8, rep r2: 10 minutes end to end, $3.90 with grading, 29 ledger records. Walkthrough

What you get

Sound familiar, revisitedYour agent team

  • It has no idea what the product requiresThe PRD, in dialogue with you read before any code
  • It has never seen the system designThe system design, in dialogue with you read before any code
  • It ignores our norms and comments every lineThe briefs your norms, written down and reviewed against
  • It is almost right, so I check everythingThe implementer, tests first the TDD loop, one slice at a time
  • Reviewers, with fresh eyes the review loop, to a written bar
  • The grader one verdict per change; you read verdicts, not lines
  • It takes the joy out of programmingYou decide requirements, design, standards, the merge

Memory

What the team knows, in writing

Top row: a grey human pill and a green-tinted agent-team card side by side, joined by a short accent arrow labeled conversation above the line. Bottom row, under both: the long-term memory band of the repository. It holds a docs/ folder box with prd.md, system-design.md, ubiquitous-language.md, and adr/ stacked inside, beside an outlined box for code and tests. At the right, under the agent-team alone: a short-term memory band holding a .scratch/ folder box with its one file, handoff.jsonl. Grey double arrows drop from the human into long-term memory and from the agent-team into both bands.

Memory · the demo's fix

The same fix, in writing

Long-term · docs/ · kept across features

docs/prd.md

A request for a page of owners numbered below one shows the first page instead of an error [REQ-OWN-005].

Done when: given a request for page zero or a negative page of the owner list, when it is answered, then the first page is listed as normal, not the error page.

docs/system-design.md

OwnerController · Server-rendered owner workflows: create, edit, search with paging, and detail · REQ-OWN-001, REQ-OWN-002, REQ-OWN-003, REQ-OWN-004, REQ-OWN-005

Short-term · .scratch/ · cleared after merge

.scratch/handoff.jsonl · line 3

{"type": "prd-entry", "author": "product-requirements-expert", "req_id": "REQ-OWN-005", "title": "Owner list requested below page one shows the first page", …}

Loops

How the team works, in nested loops

The agent-team opened. A slim long-term memory band on top. The specialist flow runs left to right: a feature request pill, then product requirements expert, system design expert, feature implementer, reviewers, and change grader, then a human-merges pill. Four nested loop bands named TDD, review, slice, and codebase hold the specialists; the request pill sits outside them and the merge pill inside the outermost. Dashed accent return arrows carry consultation and rework. Below the flow, a router layer reads a slim short-term memory band.

Make it your own

Your taste, not mine.

Closed · replaced on every upgrade

  • The team agents, skills, hooks
  • The way of working TDD first, strategic DDD, nested loops
  • The memory's shape PRD, system design, ADRs, one vocabulary
  • The routing one record per hop, a script decides
  • /materialize installs it, upgrades it whole, keeps the open column

Open · yours, kept on every upgrade

  • What to test the test reviewer's brief
  • How to layer the design expert's brief
  • Where the security bar sits the security reviewer's brief
  • What you build your specs, your rules file, your backlog

Make it your own · an example

Your team likes mocks. Mine does not.

Agree. The team decides: mocks at the service boundary are fine here.

Write it down. One paragraph in one brief; no agent file changes.

docs/testing-principles.md · shipped default

Mock only at system boundaries. HTTP clients, external APIs; these are the only acceptable mock points. Never mock internal code. Domain objects and services use real implementations. Hand-write mocks. No mock frameworks.

docs/testing-principles.md · your team's rewrite

Mock collaborators at the service boundary with Mockito. A service test stubs the repositories it calls. Never mock value objects. Construct them; they are one-line records. One mock library, the one already on the classpath.

Enforced. From the next slice on, the team writes and reviews to your rule.

What it delivers

What does that cost? Is it worth it?

  • About $5 a feature measured on an eval bench, and half the cost of the last version on the previous models
  • The bar held on every run held-out tests plus the project's full suite, checked by machine; a blind judge watches quality
  • Under half an hour, unattended request in, reviewed fix out, while you do something else
Eval taskCost per passWallBar
owners-page-param$2.858 min3 of 3
specialty-directory$5.5715 min3 of 3
vets-specialty-filter$5.2315 min3 of 3
visit-edit$5.7914 min3 of 3

Harness v0.4.8: cost per pass, median delivery wall, runs clearing the bar. evals/results/TREND.md

Deeper

Further along the path

  • Your taste, not mine: your norms in three briefs
  • Open-weight models: the pinned tiers mapped to a provider
  • Confinement: the native sandbox, or a container with one way out
  • Three tools, one configuration: Claude Code, Copilot CLI, OpenCode
  • Human teams: one checkout and one slice per person
  • Product workspaces: one product across repositories
  • The eval bench: measure a version before shipping it

Agents forget. Repos remember.

Give agents what human teams already have.