Home
Process

How we work

Every change we ship moves through the same loop, whether it is a line of copy or a piece of infrastructure: a written brief, agents building it, agents and automated checks reviewing it, a person approving it, a release, and what we learn once it is live feeding the next brief.

Specify

A change starts as a short written brief: what should be different, why, and what “done” means in testable terms. Nothing gets built from a verbal idea alone; the brief is what agents and people both work from, and it is the thing we revise when something does not fit, not the code first.

Build

Agents write the code, often several at once, each holding one piece of the brief. An engineer directs them: setting the direction, splitting work into pieces an agent can hold in one pass, and stepping in wherever judgement is needed.

Review

Before a person looks at anything, agents review each other’s changes and the full check suite runs: types, tests, broken links, and this repository’s own written rules. Nothing reaches a person half-broken.

Approve

A person reads the diff and decides. Agents draft the explanation of what changed and how it was checked, but the decision to ship stays with an engineer, every time, with no exception for small changes.

Ship

An approved change deploys on its own, usually within minutes, as one of many small releases rather than a scheduled batch. Each one is small enough to read in full and, if it turns out wrong, small enough to undo.

Observe

Once a change is live, we watch what actually happened, not just that the build stayed green. What we see there writes the next brief, which is why this is a loop and not a line.

Why shared infrastructure

We’ve seen this pattern before, across more than one team: without shared infrastructure, each one writes its own orchestration, its own guardrails, its own way of catching when an agent gets something wrong, and learns the same lessons on its own schedule, separately, months apart. Left alone, that cost repeats itself every time a new team starts; built once, it turns into speed every team draws on instead of paying for again.

So we set out to make the whole loop as rational as its parts: an engineer connects only at the points that actually need one — a decision with real stakes, a judgement call on safety or security — and nowhere else. The orchestration, the guardrails, the checks that catch a mistake before it ships: built once, run by agents, shared across every team that builds on top of them.