Skip to main content

compound

Use when finishing a non-trivial task, fixing a bug, completing a feature, or wrapping up a session and you want the work to make the system smarter next time. Runs the compound loop — consult memory, do the work, verify with an independent subagent (max 3 cycles), then distill only CONFIRMED lessons into STATE.md and memory. Triggers on "compound", "make this stick", "close the loop", or end-of-task wrap-up.

Source facts

Repository
sethdford/claude-toolkit
Last source activity
June 24, 2026 at 11:36
Detected SKILL.md language
English
Stars
0
Forks
0

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

File Explorer
2 files

Showing SKILL.md

SKILL.md
Source instructions · Read-only preview
name
compound
description
Use when finishing a non-trivial task, fixing a bug, completing a feature, or wrapping up a session and you want the work to make the system smarter next time. Runs the compound loop — consult memory, do the work, verify with an independent subagent (max 3 cycles), then distill only CONFIRMED lessons into STATE.md and memory. Triggers on "compound", "make this stick", "close the loop", or end-of-task wrap-up.
# Compound — the self-improving loop Make this session leave the next one smarter. The loop enforces the five-stage progression **fail → investigate → verify → distill → consult**. The discipline that matters is **never writing a lesson until an independent verifier has confirmed it (stage 3) and you've generalized it into a rule (stage 4)**. Logging raw failures is not compounding. Create a TodoWrite item per step below and work them in order. ## Step 0 — CONSULT (read before doing) - Read `STATE.md` at the repo root if it exists. If it doesn't exist and this is a real project, create it (automatically — don't ask) with exactly these sections: ```markdown # Project memory · <PROJECT NAME> ## Now <!-- what we're actively working on --> ## Verified facts <!-- stage 3: things we stopped guessing about, each with how it was verified --> ## General rules <!-- stage 4: distilled rules that apply beyond the specific case --> ## Open failures <!-- stages 1-2: symptom · hypothesis · reproduction (command or file:line) --> ## Lessons learned <!-- stage 4 distillations not yet promoted to rules --> ## Waiting for human <!-- blocked items after 3 failed verify cycles: what's blocked · tried · needed --> ## Last session <!-- stage 5 resume pointer: timestamp · what landed · what's next --> ``` (The same skeleton also ships as `STATE.template.md` beside this skill, with fuller comments.) - Skim your Claude Code memory (the `MEMORY.md` index is auto-loaded into sessions). Pull the "Verified facts" and "General rules" into your working plan so you don't re-derive what's already known. ## Step 1–2 — WORK, then INVESTIGATE failures - Do the task. - When something fails, do **not** just move on. Spend a beat on *why*, then append to `STATE.md` → **Open failures** with: a one-line symptom, your current hypothesis, and a concrete reproduction path (command or file:line). This is stages 1–2. ## Step 3 — VERIFY (independent, max 3 cycles) Dispatch the **`verifier`** subagent shipped with this plugin — do NOT grade your own work. (It registers as `verifier`, or as `compound-loop:verifier` when installed as a plugin; either name resolves.) ``` Agent(subagent_type: "verifier", prompt: "<what changed, the rubric/acceptance criteria, and where to find the artifacts>") ``` The verifier runs the project's tests/lint/build itself and returns `VERDICT: PASS|FAIL` with evidence and gaps. - **FAIL** → fix the named gaps, re-dispatch. Cap at **3 cycles**. - **3rd FAIL** → stop. Write a clear entry under `STATE.md` → **Waiting for human** (what's blocked, what you tried, what you need) and surface it. Do not declare success. - **PASS** → continue to distill. If there are no runnable checks (e.g. docs/config), give the verifier explicit acceptance criteria so it still grades against something concrete, not vibes. ## Step 4 — DISTILL (only after PASS) Turn the verified outcome into a **general rule**, then write it to the right scope: - **Project-specific fact or rule** → `STATE.md` (Verified facts / General rules). - **Cross-project rule** ("X always breaks on Y") → a new file in your Claude Code user memory directory + a one-line pointer in `MEMORY.md`. - **A repeatable procedure** → sharpen the relevant **skill** (add a "Known failure modes" or "Anti-patterns" note). Procedural memory travels further than a state file. Write the *generalization*, not the incident. "Auth middleware must be rate_limit → jwt → rbac; reversing causes 401s" — not "fixed the 401 today." ## Step 5 — POINTER (resume, don't restart) Update `STATE.md` → **Last session**: timestamp, what landed, what's next. The next session reads this first and resumes instead of rediscovering. ## Guardrails - **Maker never grades maker.** Verification is always the `verifier` subagent. - **No unverified lessons.** Distillation is gated on a verifier PASS. - **Respect the memory budget.** Only the first ~200 lines / 25 KB of `MEMORY.md` auto-loads into subagents. Keep the index lean; consolidate when it grows. - **Bias to honesty.** If the verifier couldn't actually run the checks, treat it as not verified — write to "Waiting for human," not "Verified facts." ## Provenance Patterns adopted from [`cobusgreyling/loop-engineering`](https://github.com/cobusgreyling/loop-engineering) (five primitives, state file, the "Verifier Theater" failure mode; endorsed by Boris Cherny) and Anthropic's official sub-agents / memory-tool docs. Full design in `docs/DESIGN.md`.
View on GitHub