The delivery system

Agents write most of the code here. That works because everything around them is engineered: the context they read before they start, the isolation they build in, the review whose job is to break what they wrote, and the pipeline that ships it and watches it in production. Six disciplines, each with the artifacts it leaves behind, applied to every application and every engagement.

1. 01

   Spec, Review, Repeat

   Every feature starts as a written plan: the problem, the chosen approach, the rejected alternative, and the criteria that decide when it is done. The plan is reviewed before any code exists and revised until it survives review. It lives in the repo beside the code it describes, so the reasoning ships with the change and outlives the session that made it. Agents execute plans. They do not invent them.

   In practice: plans committed beside the code · the rejected alternative on record · success criteria before the first commit

2. 02

   Engineer the context

   An agent is only as good as what it reads first. Each part of a codebase carries its own conventions file, so an agent inherits the rules of the code it is touching. A committed knowledge graph of the codebase is the first search tool: a query returns the scoped subgraph around a question instead of pages of raw grep output, so the tokens spent on a question stay small as the repo grows. Memory is updated in band, during the work, and out of band, between sessions, so what one session learns the next one starts with.

   In practice: per directory .md conventions · graphify knowledge graph, committed with the code · memory updated in band and out of band

3. 03

   Agents implement Test Driven Development

   Agents work test first: the failing test is written before the code that makes it pass, so every change arrives with proof of what it does. Orchestrated coding agents work in parallel, each in its own worktree with its own database and port, so no two agents can contaminate a diff or serve each other's app. A dispatched agent pushes after every commit, so its progress is visible from outside without interrupting it. Agents reach the systems they operate through MCP tooling: typed, permissioned access to the deploy platform, the docs, and the telemetry instead of an unrestricted shell. Hooks run at every tool call, so a convention is a gate, not a suggestion.

   In practice: a failing test before the code · one worktree, database, and port per agent · a push after every commit · MCP servers for deploys, docs, and telemetry · hooks that gate tool calls

4. 04

   Review to break, not to confirm

   Every branch gets an adversarial review before it is pushed: a separate reviewer whose brief is to falsify the change, sized to the diff, with more reviewers and stronger models as the risk grows. Every new test assertion is proven by mutation: break the code it covers, watch it fail, restore. Dependency and security audits run on every project and land in their own pull requests. Nothing merges unread, and nothing merges on a green suite alone.

   In practice: review sized by diff and risk · mutation tested assertions · dependency and security audits · CI green plus review as the merge gate

5. 05

   Feedback compounds

   Every correction becomes a rule with a date and the incident that produced it, written into the conventions the next agent reads. When a decision changes, the document that recorded it changes in the same pull request, so a convention never silently stops matching reality. The system gets stricter with every incident, and the tenth project starts where the first one ended.

   In practice: dated rules with their origin · docs updated in the same PR as the decision · memory that persists across sessions

6. 06

   Operate with confidence

   Every change ships through a pipeline: typecheck, unit, and end to end suites on a fresh runner, then deployment through blue green windows, so a release can be watched and reversed. Production is verified by asserting on what the site actually serves, not on a status code. Every application runs with OpenTelemetry logs, traces, and metrics, alerting, and a cost ceiling. Operating the portfolio is where the engineering judgment on this site comes from.

   In practice: CI gates on every push · blue green deployment windows · OpenTelemetry logs, traces, and metrics · alerting and cost ceilings