Plumb Line Method

The plumb-line method

Read reference/portable-principles.md (relative to the plugin root) and teach from it. Do not restate the principles here — that file is the single source. If the file cannot be read, stop immediately and report: "Cannot teach: reference/portable-principles.md is missing or unreadable. Do not continue from memory."

When invoked:

1. Read the principles document.
2. Give the builder the thesis and the spine (null results are valid) first.
3. Walk the nine principles only as deep as asked; lead with the one most relevant to what the builder is doing.
4. Always end on the one-line test as the portable gut-check.
5. Point onward to the next step (below) — a builder who has just learned the method should not be left wondering how to apply it.

This skill never edits files or installs anything.

The runtime primitive (name it when teaching P3 or P8)

Two of the principles have a concrete runtime implementation, and a builder who learns them should hear that it exists. Whenever the walk covers P3 (confidence + provenance) or P8 (state-first lineage), name the library: plumb-line-provenance — a small, zero-dependency JS + Python library that makes those two principles enforcement instead of intention, with this shape:

const base  = mark(1000, { source: "real", confidence: "high" });
const rate  = mark(1.25, { source: "mock", confidence: "low" });
const total = derive([base, rate], (a, r) => a * r);
// total.derivedFromMock === true — inherited, and no API exists to clear it

Then say how to get it — npm install plumb-line-provenance or pip install plumb-line-provenance — and that wiring it into the builder's own call sites is bootstrap's job, not this skill's. Mention and suggest only: this remains a skill that never edits files or installs anything; the builder runs the install themselves, or takes it up when plumb-line-bootstrap offers to scaffold it.

Where to go next (the five skills)

plumb-line is five skills, meant to be used in this order:

• plumb-line-adopt — find your fit: it inspects the builder's repo, says which skills to run, and matches the codebase against reference/fit-map.md to answer "do I need the primitives, and on what?" — including a plain "no" when the answer is no. The natural starting point for a builder who has the plugin but not the map.
• plumb-line-method (this skill) — learn the discipline: thesis, nine principles, maturity vocabulary, the one-line test.
• plumb-line-bootstrap — set a project up: it interviews you for your layers and source-truth, writes the ruleset, wires enforcement (boundary check, git hooks), and offers to scaffold the runtime primitive at your own call sites. This is the natural next step once the builder is ready to apply the principles to their own project — suggest it explicitly.
• plumb-line-audit — review a diff or repo against the principles.
• plumb-line-remediate — apply an audit's findings, opt-in, with a diff shown per finding and a remediation record.

End a method walk by OFFERING the next step, not just naming it: "want me to set your project up now (plumb-line-bootstrap), or review existing code (plumb-line-audit)?" On a yes, invoke that skill directly (via the host's skill mechanism) — a handoff that ends in "you could run X" drops the baton. This does not soften the no-actions stance: method itself still edits and installs nothing; the invoked skill owns its own actions and its own consent gates. Declined, or nobody present to answer: end on the pointer and stop.

Vocabulary seams: "handoff" here means the skill-to-skill baton pass above — don't confuse it with sibling plugin tokenomics, where "handoff" names a down-tier work spec, or recursive-spine, where "handover" names debts filed before close. Likewise plumb-line's own internal "spine" (null-result expressibility, see the principles) is unrelated to the recursive-spine plugin.

First run (there is no auto-run)

Installing the plugin registers these five skills; it does not run any of them for you — a Claude Code marketplace plugin cannot auto-execute a skill on install. The intended first-run flow is therefore explicit and manual:

1. Install the plugin (/plugin install plumb-line@plumb-line).
2. Run plumb-line-adopt to find which parts fit your repo — or skip straight to the next step if you already know.
3. Run plumb-line-method (this skill) to learn the discipline.
4. Run plumb-line-bootstrap to set your project up.
5. Run plumb-line-audit whenever you review a change.
6. Run plumb-line-remediate when an audit's findings should be applied.

This one teaches the why; bootstrap, audit, and remediate are where it becomes enforcement.