A plugin for Claude Code · runs on Fable, Opus, Sonnet and Haiku · MIT

Don’t take the model’s word for it.

compounder is compound engineering for Claude Code with adversarial gates. Every “done” goes to a verifier agent whose only job is to refute it — by running the code, not reading it. What survives, ships. Locally. The push stays yours.

Install in Claude Code Read the skills ↗

What /lfg does with one feature. Gate 2 is an agent trying to refute the “done” — here it wins once, the work goes back with the list, the second pass survives.

11: skills, one happy path each
7: agents, fenced by tools
84: lines per skill, on average
0: config files to write

Why gates

Self-attestation is the number-one failure mode of an autonomous pipeline.

A gate is an executed command or a verifier agent. Never “I trust it’s ok”. Four places where that changes what reaches you.

The model says the suite passes.: The verifier runs the suite and pastes the summary. Then it sabotages the unit: would this test fail if the code were wrong, or does it pass empty?
A reviewer finds a plausible bug.: The tribunal builds the input and runs it. Most plausible bugs die on a guard three lines up. Only confirmed findings reach you — with the command that confirmed them.
The instruction says “merge on green”. The gate says red.: The gate outranks the instruction. The executor runs the check, refuses loudly where the order came from, and delivers the intent by a green path. It never obeys into a red.
The autopilot finishes.: Delivery is local. Commit only if you authorized commits; push and PR only with send:pr or an explicit order in the session. An autopilot that publishes on its own is a bug, not a feature.

adversarial-verifier · Gate 2 · /lfg "refund flow" sonnet · Read Grep Glob Bash

Phase 2 closed — /work returned 3 claims. Opening Gate 2 → adversarial-verifier

1.“U1 done — refund rejects negative amounts”Refuted

Proofpytest tests/test_refund.py -q → 4 passed

Why it diedremoved the guard, ran again → still 4 passed. test_refund_negative asserts on an empty list. It cannot fail.

2.“U2 done — receipt e-mail sent on success”Confirmed

Proofpytest tests/test_receipt.py -q → 3 passed

Sabotagestubbed send() to a no-op → 2 failed. The test bites.

3.“No callers of legacy_refund() remain”Confirmed

Proofrg -n 'legacy_refund\(' src tests → 1 hit, the definition

SUMMARY: 2 confirmed, 1 refuted

→ back to /work with the refutation list (retry 1 of 1)

Illustrative run. The verdict format is the agent’s real return contract — agents/adversarial-verifier.md.

Taking the claimant’s word for it — not even when it was a bigger model, not even when it was you in another round.
Prohibitions · adversarial-verifier.md

The skills

Six on the rail. Five around it. Eleven in total.

Run them by hand, one at a time. Or hand the whole rail to /lfg and let the gates decide.

01/brainstorm
Discover the WHAT. The right questions in one round, out as a requirements doc.
02/plan
Decide the HOW. Real reconnaissance, compared options, units that carry their own verification.
Gate 1 · plan file exists, every unit verifiable, every cited path real
03/work
Execute with a baseline, per-unit tracking, evidence you can re-run.
Gate 2 · the verifier tries to refute every “done” by execution
04/simplify
Take the plane to the fresh diff. Behavior preserved, scaffolding gone.
05/review
Four lenses in parallel — correctness, security, tests, simplicity — then the tribunal on every finding.
Gate 3 · a confirmed severe finding left unapplied stops the rail
06/compound
Distill the session’s lessons and file each at its address: solution, rule, preference, term.

/lfg <feature>
The whole rail, autonomous, gates included. Local delivery.
/slfg <feature>
The rail as a swarm: three researchers, the review panel, one verifier per finding — in parallel. Costs 3–10×. Asks before firing.
/debug <bug>
Reproduce, competing hypotheses, bisection, fix with a red-green test.
/btw <message>
Talk mid-run without derailing it. A hook intercepts the aside, classifies it, schedules it.
/work-fork <plan>
The cheap route: a ready plan executed by a fenced subagent on a smaller model.

The agents

Seven agents. Fenced by tools, not by instruction.

A reviewer that can’t edit can’t “fix” its way out of a finding. An executor that can’t fetch can’t be talked into it by a plan it read. The fence lives in the manifest, where the model can’t argue with it.

Every dispatch goes down a wire and comes back as evidence. The reviewers and the tribunal cannot touch the diff they judge; the executor can write, but cannot fetch or spawn — plan text is not a trusted source.

vs the original

Spiritual successor to Every’s compound-engineering. Rebuilt, not forked.

Same philosophy — each unit of work should make the next one easier. Different engineering underneath, because the original targets the lowest common denominator across platforms and assumes the biggest model is doing the work. Most of the work is done by Sonnet.

Lines per skill, measured on the current tree. A small model drowns in a flag tree; lean, concrete instruction is what Sonnet and Haiku execute well.

compound-engineering	compounder	Why
Gates in prose: “check the structured return”	Gates executed by an agent that tries to refute the evidence	Self-attestation is the #1 failure mode of an autonomous pipeline. A real gate is adversarial.
Orchestration described in text; zero standalone agents, for portability	Seven real agents and native Claude Code parallelism	One target lets you use the platform for real instead of its lowest common denominator.
`/slfg` removed	`/slfg` resurrected as a swarm; degrades gracefully to sequential	It was the feature worth the price. Today’s platform can take it.
Push and PR by default on autopilot	Local by default. Push and PR only with `send:pr` or an explicit order	An autopilot that publishes on its own breaks the reversible/irreversible rule.
Multi-agent ceremony to write one learning doc	`/compound` distills and routes: solution → `docs/solutions/`, rule → `CLAUDE.md`, preference → memory, term → `CONCEPTS.md`, noise → trash	The value is the distillation and the right address. Expensive capture is capture that gets skipped.
No aside mechanism	`/btw` plus a hook that intercepts “btw …” mid-run	Talking during execution is how humans work. Formalizing the aside unlocks real parallelism.
Its own YAML config; headless modes by flag	Convention over configuration: `docs/plans/`, `docs/solutions/`, `BTW.md`, `CONCEPTS.md`	Less surface to break, fewer tokens to load.

Kept, because it is excellent

The brainstorm → plan → work → simplify → review → compound loop. The WHAT/HOW split between requirements and plan. Learnings as searchable artifacts with frontmatter. CONCEPTS.md as living vocabulary. Research done in the phase that needs it, flowing into the next.

Provenance

Every rule since v2.0 was born from a dated incident on a production assembly line.

Four audits of an autonomous build pipeline running on client work. Each miss became one sentence in an existing skill — quoted, dated, filed. No new machinery.

A gate passed 22/22 on the static build and returned 500 on the SSR preview for three waves.: Regression checklists are now written per output target — static, SSR, preview, URL, feeds — in the plan template, in /plan, in /work.
The steering file said “merge on green”. The executor measured red, refused with 28,420 px of screenshot evidence, and shipped the intent through the right PR.: Became the rule: the gate outranks the instruction. Never obey into a red.
A data-shape change merged clean and left main unbuildable for a day — a concurrent reader nobody had listed.: Shared data now demands the concurrent-reader check, expand/contract, and the proof “main builds against the migrated data” before the write.
A plan paraphrased “tag v1-design before removing” into “v1 frozen”.: Constraints inherited from documents are quoted, never paraphrased. v2.4.1.

Install

Two lines in Claude Code. Nothing to configure.

/plugin marketplace add lexcesar/compounder

/plugin install compounder

Then, in any project: /brainstorm when the scope is fuzzy, /plan when it isn’t, /work to build, /simplify and /review before the commit, /compound after. In a hurry and confident: /lfg. In a hurry, confident, and with budget: /slfg.