Parent: principles
A good audit point is one where the check is cheap and deterministic in the auditor's context. Not cheap in the abstract — cheap given what the auditor can actually see.
Cheapness is the precondition, not a bonus
If verifying costs what generating costs, the auditor is just a second generator and you have bought a vote, not a guarantee. Cost asymmetry is what lets audit-as-membrane terminate the verification regression: the check performed in the crossing is cheap enough that it does not itself need certifying. Remove the asymmetry and the membrane collapses back into a node, and the regress resumes.
The qualifier carries the weight
Cheapness is not a property of the predicate. It is a property of the predicate relative to what is in the auditor's context. "Mean volume above −50 dB" is a lookup when you hold the rendered file and a simulation when you hold a plan.
So audit-the-artifact is a corollary, not an independent law. The reason to audit the real artifact is not only honesty — it is that the artifact is what makes checks cheap. A description makes every check expensive, because answering any question about it requires reconstructing what it describes.
This also widens what counts as "the artifact": a registration form, a support inbox, a live endpoint. Anything the check can be run against rather than about.
Three axes, not two
Cheap and deterministic checks are also the easiest to satisfy vacuously. has_audio_stream: true is cheap, deterministic, and was exactly the trap; only audible caught the silent track.
- cheap — the auditor can run it inside its own context
- deterministic — the membrane stays a shim; no error bars enter the trusted base
- tight — the passing set is not much larger than the acceptable set
Cheap plus deterministic plus loose is a rubber stamp with a green light on it — worse than no check, because it manufactures confidence.
Cheap checks are Goodhart targets
The cheaper and more deterministic a check, the harder a generator optimises to pass exactly that check. So the best-sited audits need company: several non-collinear checks probing different failure modes. A single cheap check is a specification of how to cheat.
The strong form: audit points are built, not found
If good audit points are where checking is cheap, the lever is not searching harder for places to check. It is shaping the artifact so that checking becomes cheap:
- structured output instead of prose → schema validation replaces reading comprehension
- gates-with-margins → a signed distance instead of a bare boolean; still deterministic, strictly more informative
- structured verdicts plus a deterministic minting shim (audit-as-membrane) → the stochastic judge never holds the pen
Those three read as three separate engineering lessons. Under this criterion they are one move, applied three times: convert an expensive or non-deterministic check into a cheap deterministic one by changing the shape of what is produced.
Corollary: stratify by determinism
Fully deterministic checks — schema, grep, exit codes, ffprobe — go outermost and run first, as hard gates. Stochastic checks — a vision judge, a model reviewer — run only once the deterministic layer has passed.
The stochastic component the trusted base absorbs is then never at the first door, and everything ahead of it is reproducible. audit-as-membrane warns that an AI in the membrane turns trust from an absolute into a calibrated measured quantity; stratifying decides which layer that happens at instead of letting it happen everywhere.
The useful negative result
Some properties have no cheap deterministic proxy — "is this the right question", "does this read as though a person wrote it". The criterion's value here is that it says do not site an audit point at all. Hand it to a human, a sample, or a bet, rather than dressing it as a gate. A gate that cannot be cheaply checked is theatre wearing the costume of rigour.
One line: an audit point exists where checking is cheaper than making — and you get more of them by reshaping the artifact, not by looking harder.