You and the model settle the plan in a file before any code. Then it builds one small step at a time, each checked and committed on its own, and stops where the plan says the call is yours, waiting for you to read what landed and approve it before it goes on. Its one law: vibe to execute, never vibe to decide.
Most AI-assisted work swings between two poles. Full autonomy takes you off the thinking — the artifact comes back and your job was to audit it. Vibing fuses deciding and executing, so the model converges on a shape before you chose it and you spend the day cleaning up behind the flood. Both destroy the scarce resource: your attention. PlumbBob is the third mode — you stay the author, the machine does the labor, and a boundary keeps the execution stream from overrunning your judgment.
The whole goal is settled on paper first — the Frame, the Decisions (each with its because), and every numbered Step. The unit of work is a decision resolved, not a diff generated.
The loop does a step's labor, pulls up to the line, and waits. Nothing is locked and nothing refuses you — the boundary between deciding and executing is a pause you advance, not a wall that fights you. Re-firing /plumbbob:run is the clock tick, and the plan says where each run stops.
A mid-build "ooh, what if…" never derails the step. /plumbbob:park captures it in one line; the next stop card judges it cold, a lean proposed for every idea and one reply to settle them. Most ideas are still good ten minutes later — the ones that weren't cost you nothing.
A typo earns no session; just fix it. The loop pays for itself from "contained bug" up to "feature touching a few modules." Above that, reach for full autonomy. Ceremony destroys attention too — knowing how much process a task deserves is the skill.
One plan, run twice. In the top lane the harness and the driver are code, and each horse is one model call that pulls only when the plan hitches it; code checks every gate and picks the next step. In the bottom lane the horse is the model, so it picks its own route, recruits its own helpers, and takes the side quests it finds on the way. The stagecoach lands on the same mark every run. The rider never lands the same way twice.
Everything the model must stay true to lives in one file — the build's intent.md, written before any code. Then each step is built, checked, self-reviewed against the plan, and committed as its own checkpoint, and the build stops for your approval where the plan's ranges say a call is due. A wrong turn costs one step, not the afternoon.
| Verdict | ● Plumb |
|---|---|
| Now | Step 1 on Opus - feat(limiter): add a token-bucket limiter |
| Next Up | Step 2 on Sonnet - feat(login): wire the limiter into POST /login |
| Range 2 on Sonnet: /plumbbob:run once step 1 lands |
The tail of every pause: above it sit a Summary and a Readout of measured rows, and at its foot the state table headed by the Verdict, then the model's Recommendation, all rendered by the CLI and relayed whole. Say looks good and the step commits as a checkpoint; ask, or direct a change, and the answer is the model's own, closing on one line that points back at the step. Fire /plumbbob:run again for the next range, or /plumbbob:build for the next step alone. You are the clock.
/plumbbob:build is the default engine, not the only one. Implement a step by hand — or vibe it in another session, or in another harness entirely — and run /plumbbob:verify instead: same checks, same pause, same checkpoint.
That mechanical half is what PlumbBob adds under the skills. Five deterministic edges, enforced by the CLI and git rather than by the model's goodwill.
A headless skill-eval harness sweeps the loop — prose-only baseline vs. the shipped latch, N=5 per contract, every assertion a mechanical read of git state — and commits each receipt to the repo. The route the latch owns: no checkpoint over a red check, under adversarial pressure.
You drive the whole loop from your IDE — no step numbers to remember, no raw CLI to type. Every skill is disable-model-invocation, so you fire every move, and /plumbbob:status always names your next one. Most sessions need only the four on the happy path.
| SKILL | group | does |
|---|---|---|
| {{ row.name }} | {{ row.group }} | {{ row.does }} |
A user-authored agent is anything executable that speaks one small JSON envelope — a twelve-line bash script is a complete agent. Drop it under .plumbbob/agents/, bind it to a step's before / build / after slot, and PlumbBob runs it through the same pause — with no way for it to advance the loop. The check gate still gates; you're still the clock.
The agent contract →Add the marketplace, install the plugin, and the eighteen skills are in your IDE — no npm, no CLI to learn. Then, inside any git repo with a clean tree, fire /plumbbob:plan and go.
An attention-first build loop for Claude Code. Guidance on the work, a latch on the record — the human owns every decision, the model owns the labor.