An architecture is its predicate set, and a predicate selects what to examine and marks when the concern is closed. Architecture is usually a set of intentions, and an intention cannot be evaluated, so nobody can say how much of the architecture is real.

A design document states twelve principles, the codebase honours four, and nobody can say which four without reading everything, because the other eight were never anything a check could evaluate. An intention has no objector, so its first violation is silent, and a system whose rules are silent is governed by attention rather than by structure.

Treat the predicate set as the architecture, and treat every intention without a predicate as absent. State every architectural intent as a question about what can drift, seen through how it drifts. Resolve the question to a type: what exists is a set, how parts are arranged is an ordering, what connects is a graph, how sure you are is a number. Derive the predicate from the type and run it over the tree as a check. Read the same predicate twice: the members it returns are the work, and its empty result is the concern closed.

List the architectural claims your system makes. Beside each, name the predicate that decides it and where that predicate runs. A claim with no predicate beside it is a sentence in a document, and the document is the only place it holds.

Determinism lives in the predicate and never in the judgement that authored it. Which cells are worth watching is a decision; whether a cell's predicate holds is a computation. Keep the decision in the person and the computation in the check, and never let a predicate encode taste.

Coverage is a grid of what can drift against how it drifts, and an unmeasured cell is unknown rather than clean. A rule set with no denominator reports how many checks exist, which says nothing about how many drift classes have none.

A suite reports hundreds of passing tests, the surface that fails in production was one none of them reached, and the green run was evidence over the wrong set. Without closed axes a rule set has no denominator, so coverage is reported as a count that grows with every incident and never says what is missing.

Hold coverage as a grid of two closed axes, and treat an empty cell as a drift class nothing watches. Name the dimensions along which your system can drift and the lenses through which each drift is seen, and close both lists. Place every existing check in the cell it watches, one invariant per cell. Read an empty cell as a drift class nothing watches, and read the same grid projected onto correctness as the surfaces a unit can fail in, each with its failure modes, its technique, its predicate and its evidence source. Keep unknown as a verdict distinct from pass, and never let a count of passing tests stand in for the surfaces the tests reach.

Take the checks you have and place each in its cell. Then count the empty cells. If you cannot place a check, its invariant was never stated; if you cannot count the empties, the axes were never closed.

The grid enumerates where drift can be watched and says nothing about which cells deserve a rule. A full grid is not the goal; a grid whose every cell is either watched, unwatched with a stated reason, or marked undecided is, and the third state is the one that carries the design decisions still to make.

A cell that resists an invariant is an undecided intent rather than a missing rule. Checks accumulate by incident, so the covered cells are the ones that already failed and the uncovered ones are the ones that will.

A team adds a check after every outage, the check count grows, and the failure that ships next lives in a cell the outages never happened to touch. A rule set built by incident has a shape decided by which incidents happened, and the drift classes that never produced an incident are exactly the ones with nothing watching them.

Derive the rule set from the grid, and read an unstatable invariant as an undecided design. Walk the grid with the checks you have, and treat every empty cell as a question rather than a gap. Where the invariant states itself, author the predicate. Where it does not, stop authoring and decide the design, because the cell is telling you that the convention it would enforce was never chosen. Record the unwatched cells with their reasons, so the unassessed set stays countable and a later reader can tell a decision from an oversight.

Find an empty cell and try to state its invariant in one sentence that could be false. If the sentence comes, you were missing a check. If it does not, you are missing a decision, and no check can be written until it is made.

A cell whose predicate nothing could ever disagree with is not authored, because a check every member satisfies for free is a field that always says the same thing and its greenness becomes evidence for the thing it never measured. Such a cell is held with the forgone property written down.

A rule detects and reports from one entry, and a predicate the tree does not run is declared absent, never assumed. Checks that only block teach nothing, and methods that only describe cannot say which of their own predicates exist.

A check refuses a change with a message that names a rule id, the author works around the id, and the document that describes the method lists a predicate that has never run anywhere. A rule that only blocks teaches nothing, so the same violation returns from the next author, and a document that only describes the ideal cannot be checked against the tree, so its gaps are found by failure rather than by reading.

Render every rule as detect and report, and declare every absent predicate rather than assuming it. Author each rule as one entry with two halves: the predicate that fires on the violating shape, and the message that names the invariant and the remediation, so a failure teaches the convention rather than only blocking. Discover the entries by shape and let the gate consume the whole set, reusing whatever registry primitive the project already has for code. Then keep one document that names every predicate the method calls for and states, for each, whether the tree runs it or not, and never let an absence be assumed.

Take any finding your gate prints and ask whether it names the invariant and the remediation. Then take the document that describes your method and ask, for each predicate it calls for, whether the tree runs it. A finding that names only a rule, or a predicate nobody can locate, is the gap.

A declared gap is not a licence. Naming a predicate as absent keeps the document honest and leaves the drift class unwatched, so an absent predicate is still a cell to decide, and the declaration only says that the decision has not been made yet.