Products shipped in weeks,
at a bar that holds
as the work grows.

This is the one page of the system I would hand to a manager who has never touched an agent, because it is the whole difference between delegating and dictating, and it does not change when the workers stop being human.

It is also the rule I break most. By the time a task is framed properly I usually know how I would do it, and writing that down feels like generosity rather than interference. It is neither. Every other rule in this case has a machine behind it: a hook that refuses, a gate that will not open, a judge that will not sign. This one has a sentence in a template, and a sentence has never refused anything.

So the sentence gets typed by hand every time the section appears, and it is always the same move. I write down what I thought, then take its authority away in the next clause. The wording drifts from task to task, and that drift is the tell. A rule being applied reads differently from a macro being pasted.

The cost of getting this wrong is not a worse result. The work comes back. I end up holding the context I split out, and the session I delegated to becomes an expensive way of typing. That failure has a name in the system now, and I gave it one because I kept doing it with a decent reason every time.

Every operating model looks good running forwards. The test is what it does when a decision made months earlier turns out to be false, which is the normal condition of product work and the thing most process diagrams quietly omit.

On the job-search extension, the strategy promised that applying would cost zero extra clicks: the tailored CV would attach itself to the application form. It was specified, costed and built.

Implementation revealed the file being attached was HTML wearing a .pdf extension. Most application systems check, reject it, and the ones that accept it store something unreadable. Then the audit found the worse half: the panel never read the result, so it reported success either way. The user believed the CV was attached and submitted an application without one.

The resolution was not a better attach. It was deleting the automation and adding a click, with the reasoning written down where the next person will find it.

What matters structurally is what happened next. The change was classified, its blast radius mapped across every dependent artifact, and the update ordered upstream first. The earlier decision was not edited to look correct. It was marked superseded, with the newer one naming exactly which part of it died.

This is the part with no equivalent in a human organisation, and it is the one I am proudest of.

For each kind of work, a manifest declares which roles must participate and in which wave. A run produces a trace of who actually fired. The harness diffs the two and reports what was missing, what fired that should not have, and what ran out of order. It exits non-zero on any finding, so it drops into a pre-commit hook like any other test.

Which means "for this kind of task the right people were involved" stopped being an impression and became a machine-checkable verdict.

The fixture below is a real one. An early version of a scenario ran marketing, then design, then build and test, and looked complete. It was missing the wave where the product manager creates the unit files, and without those files nothing downstream is gated at all. That omission is now a permanent test: the old trace runs against the corrected manifest, and the suite fails if it ever stops reporting the gap.

Most of what a manager is handed is not a task. It is a thought that has not decided what it wants yet, and if you delegate it in that condition you get back something plausible and unusable.

So the system refuses to record one. The test is blunt and I use it on myself as much as on the agents.

Acceptance criteria have to be observable outcomes, and the task-writing skill pushes back if I give it fewer than two. That is a rule I wrote against my own worst habit. One criterion is usually a restatement of the title; the second is where I am forced to say what I actually expect to see. Two is where a title stops standing in for a specification.

A criterion also has to survive contact with the work. When one closes, what was observed goes in on the same line as what was predicted, so the file ends up carrying both halves and neither can be quietly edited to agree with the other. That is the reason I trust the backlog more than my memory of it.

Ambition needs an execution path or it stays a sentence in a brief. A single generator produces one flavour of output no matter how it is asked, so a single mockup here is assembled from several specialists, each doing the one thing it is genuinely best at.

What makes that a system rather than a pile of tools is the same discipline the roles use: every tool's skill states what it does not own and routes to the one that does. I wrote the tool boundaries exactly the way I wrote the charters, and for the same reason.

The other half is provenance. Every generated asset emits a sidecar file recording the verbatim prompt, the model, the parameters, the seed and the reference images. An asset with no provenance cannot be reproduced, which means the next person cannot change it without starting over. That next person is usually me, six weeks later.