Doctrine

Description

The artifact-shape of an operational rule — named, addressable, and invocable rather than implicit or ad hoc. A doctrine has four structural elements: a name (so it can be cited), a triggering condition (so it knows when to activate), a protected-against failure (the thing it prevents), and a citation address (where the authoritative statement lives). Without all four, a rule is just a preference or a habit; with them, it becomes an institution.

Doctrines are distinguished from individual decisions by their generality and repeatability — they apply whenever the trigger fires, not just in the current case. The most common failure mode is a rule that has the form of a doctrine but is missing its trigger, making it a bare principle rather than an actionable policy. This is why trigger-rule-pair is so closely coupled to doctrine: the trigger is what makes a doctrine load-bearing rather than decorative.

Encounters

• CLAUDE.md files — project-orientation files that state rules for agent behavior (“always read X before doing Y,” “never propose Z without W”). Each instruction is a doctrine fragment; together they constitute an operational doctrine set for the session.
• “Load-bearing instruction” — the diagnostic for which CLAUDE.md entries are genuine doctrines vs. boilerplate: does this rule actually change behavior when triggered?
• KCC PR #860 constraint — “LLM calls in production MUST use Gemini.” Named, triggered-on (any production LLM call decision), protected-against (IARC compliance failure), cited in CLAUDE.md.
• Three failure-mode gates — label-without-mapping check, flatter-vs-change-next-move check, asymmetry/reversal check. Each is a doctrine: named failure type, triggering signal, protective function.
• Code-review norms — “never merge without test coverage” is a doctrine; “write good tests” is not (no trigger, no protected failure).
• Git workflow conventions — “never push to main directly” is doctrine; “always create a PR” — similar.

When it applies / triggers on

User-initiated: User is articulating a rule, policy, or principle — especially when they use “always,” “never,” “when X, do Y,” or “our rule is.” Also when reviewing a document that is meant to govern recurring decisions (CLAUDE.md files, team wikis, architectural decision records).

Agent-initiated: Engine notices the target situation involves a standing rule or policy decision rather than a one-off choice. Candidate inference: “this rule has the shape of a doctrine — does it have a named trigger and a protected failure?” Also surfaced when a rule is being violated or when someone is asking whether a rule applies.

Vocabulary cues: “doctrine,” “policy,” “convention,” “mandate,” “standing rule,” “we always,” “we never,” “the rule is,” “per our convention,” “governing principle.”

Situation-shape signals: The presence of a rule stated without a trigger (“do X”) is an invitation to apply the trigger-rule-pair form — what condition causes X to activate?

Composes with

• trigger-rule-pair (creation relationship) — doctrine is the artifact; trigger-rule-pair is the structural criterion that makes a doctrine executable. A bare doctrine without an explicit trigger is incomplete.
• graduation-promotion (creation relationship) — doctrines are often the output of graduation: a pattern that recurred enough to be named and elevated becomes doctrine. The graduation move produces doctrines as its artifact.
• route-as-context (specialization relationship) — route-as-context is a specific doctrine: “path encodes intent.” The doctrine form is the containing category; route-as-context is a high-confidence instance.
• active-gate-vs-passive-audit (composition relationship) — doctrines often specify how errors are handled: some doctrines are gates (block on violation), some are audit-trails (record and review). The posture choice is load-bearing.

When it doesn’t apply

• One-off decisions — a choice made in a specific situation with no expectation of recurrence isn’t a doctrine. Applying the doctrine frame over-formalizes it and adds ceremony without dividend.
• Taste or heuristic — aesthetic preferences (“I prefer short functions”) that don’t carry a protected failure or trigger aren’t doctrines; they’re style. The doctrine frame inflates their status.
• Contested norms — in contexts where the rule is genuinely in dispute, naming it a “doctrine” prematurely forecloses the debate. Better to call it a proposal until it earns consensus.

Sources

• Military usage: operational doctrine as the body of standing rules for action in a domain.
• CLAUDE.md files across the James corpus (124 hits in full corpus) — the most-encountered form by raw count.
• “Named rule + trigger + protected-failure + citation” decomposition emerged from analysis of which CLAUDE.md instructions actually changed agent behavior.

Canonical exemplars from corpus (T2 2026-05-17)

Mined via scripts/mine_new_form_exemplars.py from data/backfilled-insights.jsonl. 242 backfill-only matches at score ≥ 2 — strong support; one of the most-instantiated newer forms. Top co-occurrences: cadence (31), grain (17), active-gate-vs-passive-audit (7).

• Lean-cell-doctrine refinement on provider-level photos (cwd: campconnect, 2026-05-11): “Provider-level photo dominance triggers a lean-cell-doctrine refinement… under the strict lean-cell doctrine…” — explicit named doctrine + triggering condition (artifact-class signal) + protected failure (incorrect surface choice).
• Directive sharpens the doctrine, not just adds a feature (cwd: campconnect, 2026-05-03): “Old rule was ‘save = bookmark, place = commit, only commits earn real estate.’ New rule: ‘anything the parent has explicitly placed on the calendar with date bounds earns real estate.’ That’s a load-bearing improvement because it generalizes cleanly.” — doctrine-as-named-rule whose generality is the load-bearing property.
• Doctrine-as-test rather than doctrine-as-doc (cwd: campconnect, 2026-05-03): “The unit test bookmark-only save MUST NOT emit (vague-date-intent doctrine) literally encodes the rule. Future features that try to extend the window without a specific-date commitment will trip that test, and the failure message will tell the next reader exactly which doctrine they’re violating.” — doctrine encoded in the enforcement artifact; trigger is structural (test fires on the violating shape).
• Goldfish protected hygiene over instruction (cwd: campconnect, 2026-05-03, task-notification): “A less careful agent would have run git rebase --interactive to fold the wording refinement… and broken the no-force-push rule from CLAUDE.md. Holding the line on hygiene is exactly the goldfish-smart-tier judgment we’re paying for.” — CLAUDE.md doctrine successfully invoked at the right moment.

Trigger pattern (T2): Doctrine surfaces when the user articulates a rule/policy/principle or reviews a document meant to govern recurring decisions — strong “always/never/when-X” trigger-verb signal; 242 matches with cadence co-occurrence (31) suggests many doctrines specify when they apply via cadence-shaped triggers.