compound

Overview

compound is the Claude Code plugin EveryInc/compound-engineering-plugin, maintained by Every Inc. (the media and software company behind the Cora email product). The plugin was developed in public alongside Kieran Klaassen’s “compound engineering” writing, and it packages that methodology as a large bundle of slash commands, skills, and specialist agents. The benchmark installs it via claude plugin marketplace add EveryInc/compound-engineering-plugin and pins release 2.65.0 (MIT license). The surface area is large — roughly fifty agents and forty skills — but the user-facing primitives cluster into four phases: /ce:plan, /ce:work, /ce:review, and /ce:compound, plus a handful of research, design, and git utilities.

The methodology behind the name is the thesis that each engineering task should leave the system easier to work on next time, by codifying plans, reviews, and learnings back into the repository. In practice that shows up as markdown artifacts in docs/plans/, reviewer persona subagents, and a /ce:compound step that writes learnings to a wiki-style store.

Entry point: /lfg

The benchmark drives the plugin through its beta autonomous entry point, /compound-engineering:lfg (“let’s f***ing go”). The skill file is explicit about ordering: it is a fixed six-step pipeline with stop-gates between phases.

1. Optionally delegate to a ralph-loop skill if present (not installed in the benchmark).
2. /ce:plan $ARGUMENTS — gated on producing a plan file under docs/plans/.
3. /ce:work — gated on observing code changes beyond the plan.
4. /ce:review mode:autofix plan:<plan-path> — passes the plan path so review can check requirement coverage.
5. /compound-engineering:todo-resolve.
6. /compound-engineering:test-browser, then emit <promise>DONE</promise>.

So lfg is a plan-execute-review loop with a knowledge-compaction tail, not a freeform agent. Phases are sequenced with “GATE: STOP” language rather than parallel fan-out.

What the transcripts actually show

The feature-task transcript set contains five top-level JSONL sessions and thirteen subagent logs, consistent with the plugin’s reviewer-persona pattern firing during /ce:review. Tool usage skews toward analysis over editing: 57 Read, 51 Bash, 35 Grep, 13 Agent (Task) calls, and only 12 write-side calls (Edit+Write). One session begins with the raw lfg command as advertised; another begins with the harness re-prompting the model to run ce:plan/ce:work/ce:review explicitly, suggesting the orchestrator did not always drive the full pipeline cleanly and required a manual nudge.

Bugfix and refactor runs are much leaner — single top-level sessions, one subagent each, and a single Agent dispatch — because the per-task prompt is just /compound-engineering:lfg $TASK and neither task benefits from large plan/review fan-out. The refactor run has the expected edit-heavy profile (24 Edit, 8 Write); the bugfix run stays Bash-and-Read dominant (35 Bash, 16 Read, 7 Edit).

Benchmark outcome

Across the three tasks compound lands at rank 7 of 9 with a mean z-score of -0.167. It is consistently near the cohort average rather than catastrophically weak:

• Feature (z = -0.082, rank 6/9): produces a 5-file, 892-insertion diff with 92 of 92 tests passing and zero TypeScript errors. ESLint reports 10 errors and 6 warnings — the plugin did not close the loop on style gates despite running the review phase. Tier-2 group with omc and claudekit.
• Bugfix (z = -0.487, rank 7/9): the smallest diff of the cohort at 2 files and 33 insertions. The change compiles and tests pass, but judges rated it a minimal patch relative to peers that wrote more substantial fixes.
• Refactor (z = +0.070, rank 4/9): the only task where compound is above average, with a 12-file, 157-insertion / 83-deletion diff — the kind of multi-file edit the plugin’s reviewer agents are shaped to support.

Self-preference effects on refactor are strongly positive (+12.1 judge points), meaning the opus judge liked compound’s refactor output more than the cross-judge consensus did; this pattern is common across the cohort and does not distinguish compound.

Reading of the result

compound is not a lightweight prompt — it ships a full plan-then-work-then-review pipeline with reviewer personas, gates, and a learning-capture step. In the benchmark’s single-shot /lfg invocation the pipeline does run, but its advantages (reviewer fan-out, plan artifacts) are most visible on the feature task, where they translate into a large, test-passing diff but not higher judge scores than leaner tools like pure or bmad. On the short tasks the overhead is not repaid, and the tool drifts to the middle of the pack. Residual ESLint errors on the feature task suggest the review phase verified logic but not style, which is consistent with an autofix review mode scoped to correctness personas rather than lint gates.

The plugin is more interesting as a methodology carrier — plans in docs/plans/, learnings in a wiki — than as a single-shot speed runner, and the benchmark, which rewards diff quality on one attempt with no memory carryover, is a harsh venue for that design.

Observed in trial timelines

Subagent dispatch confirms the orchestration-amortisation hypothesis: feature mean 5.2 (range 1–13, with t1 dispatching 13 reviewer/researcher agents) collapses to mean 1.0 on both bugfix and refactor. The full reviewer-persona pipeline only fires when the brief is large enough to warrant it; on short tasks compound shrinks to a single Explore.

Detail: see the per-trial timeline files linked below.

Trial timelines

Per-trial event timelines auto-extracted from session-logs/*.jsonl — skill activations, plugin/skill file reads, subagents dispatched, code mutations, Bash usage:

• feature
• bugfix
• refactor