The Assay methodology: no part grades itself

Taken one at a time, nothing in Assay's operating model is new. The brief is a ticket with a stricter template. The lifecycle is a status column with five values. The registers are a post-mortem log and an ideas backlog. The generated board is a dashboard, and the desk loop could caption half the CI diagrams on the internet. If you have read the parts list and thought I already have all of these — you probably do. The question worth an article: what turns four filing conventions and a loop into a method? The answer is one design rule applied at every joint, and it is the sentence to keep: no part grades itself — every claim one part produces is checked by a different part, under a different identity, in a form a stranger can re-run.

one drain, three corrections

Start with the method running. Merging is a throughput event, not a completion event — as of this writing, 39 merged briefs sit in the queue awaiting independent verification — and the verify desk exists to drain that queue. On July 23rd, one pass of its drain produced three corrections.

The first brief's body asserted that three named tests had been added. No file in the tree contained them; neither did the suite's output. The code under the brief was sound — the claim about it was not. The second sat at implemented with an empty Evidence section, and its deliverable did not exist: the configuration file it was supposed to populate still carried the placeholder comment naming the brief that would fill it. The third failed more subtly. Its Verify table — the block of literal commands a stranger runs to check the work — failed as written: the smoke-test rows passed a bare placeholder argument the implementation rejects before reaching the code under test. The unit-test row proved the implementation; the table did not.

None of this was fixed quietly. The three instances were filed as tracked issues, and the pattern became a findings-register entry with a stated root cause — nothing corroborates implementer-written claims before implemented is asserted — and a recommended prevention: claims about tests and deliverables belong in the Verify table's Expect column, where a verifier corroborates them, never as asserted fact in prose. The finding is dated, attributed, and still open, because closing it before the prevention lands would clear an alarm that is still true.

each part is aimed at another's failure mode

Nothing in that afternoon was one component working. It was each part catching what its neighbour, alone, would have let through — and that adjacency is the design.

A Verify table alone is a promise — worth something only when a stranger runs it, and the implementer whose claims it checks is the wrong stranger. The lifecycle supplies the right one: implementers stop at implemented, and verified requires a non-implementer to re-run the table on merged main — in the lifecycle doc's words, an implementer verifying their own work "is the narrator grading their own exam."

The lifecycle alone has amnesia. Agent sessions end; a defect diagnosed in July would be re-diagnosed in October. The registers are the memory — append-only, one file per entry, retraction by tombstone rather than deletion, because a silent edit erases the record of why a decision was made.

The registers alone are an unwired alarm — a finding sitting in a folder changes nothing. The board wires it: the generator that compiles the work queue excludes any brief named by an unresolved finding, so recorded knowledge has a mechanical consequence instead of depending on memory.

And the board alone is narration. It parses markdown written by the same agents whose work it reports, which is why it is never trusted raw: it is linted for internal consistency on every branch, written by exactly one writer — main's CI — and backstopped by the verify desk re-running the tables it summarizes.

Around the loop once, compressed: briefs make work checkable, the lifecycle makes checking someone's job, the registers make what checking finds durable, and the board makes what is durable operative. Remove any one part and the failure mode beside it reopens. That is what makes it a method rather than a stack of conventions.

The rule even governs the method's own growth. The retro register — specified, and marked in the docs as not yet implemented — is designed to walk generated inputs only ("a retro that reads its own narrative measures the narrator, not the system") and to admit at most one process change per cycle. Even the unbuilt parts are documented at their true tense.

the seams are artifacts, not reports

The desk loop makes the composition visible. An intake desk converts everything inbound into exactly one of five tracked exits — a brief, an issue, a register finding, a decision routed to the human, or an explicit rejection — so nothing arrives as ambient context. A worker pool implements, one brief per isolated worktree, behind draft pull requests. A review desk drives each PR to a recorded verdict. The verify desk re-runs Verify tables after merge. A coordinator arbitrates across streams; the human merges.

Read the diagram by its edges. Every arrow is a file, a table row, or a recorded verdict — something the receiving role can check without believing the sending role. The one edge that is not an artifact-check is the merge, deliberately: it is the single joint held by a person.

The discipline extends to absence: a desk may not report its queue empty without a fresh sweep of every board it watches, and a sweep that errors is could-not-check — blind, not idle. Even "there is nothing to do" is a claim requiring evidence.

the gate travels with the work

A brief's frontmatter records four risk answers — regulatory, customer, irreversible, sensitive-data — and its review gate is derived from them: all four no and a model may approve; any yes and closing the brief requires a sign-off naming a human. The gate is a conclusion, not an opinion, so a reviewer audits the answers rather than debating the verdict.

Carrying the gate inside the work item makes separation of duties composable. No desk needs global judgment about what is risky; the file says which class of identity may close it, and the board can render the human-gated queue without asking anyone. The board keeps the distinction honest to the last column: a brief closed over an unrun risk-bearing check is rendered with a dagger, derived from Verify-versus-Evidence coverage — a check counts as run only when a dated, attributed Evidence row names it, so silence reads as unrun.

an instrument that could not look does not answer

Everything above rests on one more rule, easy to miss because it is an interface convention, not a component. Every instrument in the tree answers in three states — checked-clean, checked-failed, could-not-check — and could-not- check never renders as a pass. The leak sweep reports it per token when it cannot prove its own search works; the desks' boot preflight reports it per check; the board stamps a DEGRADED banner naming the cause when it cannot filter already-claimed work, rather than pretending the filter ran.

This is load-bearing because every part here consumes another part's output. A two-state instrument that says "clean" when it failed to look does not make a local error — it hands an unearned green to everything downstream, and an unearned green anywhere becomes a false green everywhere. Honesty about not- knowing is not a virtue here; it is the type signature the parts need to compose at all.

what composition does not buy

The method's own documentation states the honest claim: the board is "derived from agent-authored artifacts with consistency linting," not measured from ground truth — the sensors are agent-writable. The sharpest statement of the limit is itself a register finding, filed by an adversarial review of the methodology: the verifier-is-not-implementer guarantee is enforced as a substring check on free text the verifying session writes about itself, so a single identity willing to author both the work and its record can invent a verifier name and pass. Distinct bot identities per desk narrow that gap, and the desk documentation refuses to oversell them — the identity on a commit is attribution "with an auditable trail, NOT an enforcement guarantee — anyone who can read the PEM can mint the token; the value is the trail." The enforcement fix — backing a verified row by the actor on the Evidence commit rather than the prose in the cell — is scoped as work, and the finding stays open until it lands.

Two more limits, stated as precisely as the powers. The work queue is a heuristic, not an oracle: its score rewards a stream for having aged regardless of why, and the docs say so. And for prose deliverables the Verify table is a presence gate, not a quality gate — a confident falsehood in the right section, at the right length, passes exactly as the truth would; quality stays a human judgment. What the composition buys is narrower, and real: drift, missing evidence, and contradiction become machine-visible, dated, and attributable to an identity. Attribution, not enforcement — claimed at that strength because that is the strength it has.

three words, three parties

The house compresses this system into three words: derived, linted, re- verified. Read as features, they describe tooling. Read compositionally, they are an assignment of parties — derivation to a generator the narrating agent does not control, linting to CI on every branch, re-verification to an identity that did not do the work. The method is the assignment, not the tools, which is why it ports to a stock forge and a scripting language. To apply it, walk your own pipeline seam by seam and ask, for each claim-producing part, which different part — under which different identity — checks its output, and whether the handoff between them is an artifact a stranger could re-run. Anywhere the answer is "it checks itself," you have found the place your fleet's version of those three July corrections is quietly accumulating. No part grades itself. The parts themselves, at walking pace, are in "Introduction to Assay: you don't need to trust the agents."