The Five Rungs From Advice to Absence

A Rule Can Live in Five Places

"Move it into structure" sounds like one action. It is really a ladder with five rungs, and knowing which rung you are on tells you exactly what you are still exposed to.

Rung 1 — advice. The rule lives in a document somebody read once. It governs nothing at decision time.

Rung 2 — reminder. The rule is present in the working context, right where the work happens. Better, and still the losing side of the attention contest from the previous lesson.

Rung 3 — detector. A check runs afterward and reports violations. This is the first rung that produces evidence instead of hope. It has one structural blind spot, which is large enough that the whole of the third track is about it.

Rung 4 — refusal. The tool declines the action. Not a warning, not a confirmation dialogue — the call fails and says why.

Rung 5 — absence. The affordance is not there. There is no path to the forbidden thing because nothing ever handed one over.

Rungs 1 and 2 are discipline. Rung 3 is evidence. Rungs 4 and 5 are structure. Most process failures are people trying to solve a rung-4 problem by writing a better rung-1.

Climbing Is Not Free, and Not Always Right

Every rung costs more than the one below it, and rung 5 is not automatically the goal. Absence is only available when the input is genuinely not needed. If a stage must write files, it must know paths; you cannot withhold what the work requires. That is why a real system lands on different rungs for different rules, deliberately, and writes down which.

The other cost is over-constraint. A refusal that fires when it should not is a tax on every future run, and the person paying it will eventually switch it off — which returns you to rung 1 with extra steps. The design answer is to make the guard fail in the direction that is visible and repairable: refusing too much announces itself loudly and gets fixed, while refusing too little is silent and gets discovered by an audit a month later.

The Move That Makes It Cheap

The reason this is affordable at all is that the placement itself becomes data. When each pipeline declares which of its stages close which inputs, adding a guard to a new pipeline is a line in a registry rather than a fork of the engine. The rule stops being prose in five templates and becomes one field that the harness reads.

Name the rung out loud for every rule you care about. "We have a rule about that" is not a status; rung 1 and rung 4 are both "we have a rule about that" and they have nothing else in common. Writing the rung down is what stops a team from believing it is protected by a sentence.

Code

The placement is data, not code·python

# A pipeline is a registry entry, not a subclass. Adding a guard to a
# new pipeline is a field here - the engine is never forked.

PIPELINES = {
    "create": {
        "template": "templates/<pipeline>.md",
        "revisions_kind": "create",
        "required_stages": [
            "sweep", "plan-gate", "compose", "register", "ko-cold",
        ],
        # The engine INVERTS the existence check for this one: an
        # already-existing target is an error that redirects to a
        # different pipeline.
        "new_quest": True,
        # Rung 4, scoped to one stage. `compose` has to author the
        # source language, so the guard cannot cover the whole run -
        # the sealed window is a SUFFIX here, and a PREFIX in the
        # pipeline whose last stage reconciles both languages.
        "ko_only_stages": ["ko-cold"],
    },
}


def sealed_window(pipeline: dict) -> tuple[int, int] | None:
    """First closing stage through last - inclusive, because context is
    cumulative. A seal that switches off mid-run protects nothing."""
    stages = pipeline["required_stages"]
    closing = [stages.index(s)
               for s in pipeline.get("ko_only_stages", [])]
    return (min(closing), max(closing)) if closing else None

Exercise

Pick three rules your team actually cares about and assign each one a rung from 1 to 5, with one sentence of evidence for the assignment. Then take the lowest-rung rule and write down what its rung-4 version would refuse, and what error message that refusal would print. If you cannot write the error message, you do not yet know what the rule forbids precisely enough to enforce it.

Hint

The error message is the real test. A guard has to decide, mechanically, on inputs it can see. If your draft message contains "if you are doing X for the wrong reason", the rule is a judgment call and belongs at rung 3 with a human reading the report.

A Rule Can Live in Five Places

Climbing Is Not Free, and Not Always Right

The Move That Makes It Cheap

Code

External links

Exercise

Progress

Comments 0