Repo of the day: Compound Engineering, the plugin that closes the loop between plan, code and learning

💡 What Compound Engineering is: engineering that compounds instead of decaying

The philosophy is stated right in the README: each unit of engineering work should make subsequent units easier, not harder. Traditional development does the opposite: every feature adds complexity, every bug fix leaves behind local knowledge someone else has to rediscover from scratch. Compound Engineering flips the ratio — 80% of the time goes into planning and review, 20% into execution — and adds a step most workflows skip: every cycle closes by writing a learning note the next cycle reads as its starting point, instead of starting from zero again.

The project is maintained by Kieran Klaassen and Tyler Chow at Every, the studio behind the Cora email app, and it's explicitly 'opinionated': its direction reflects a specific point of view on how agent-assisted engineering should work, and not every outside contribution gets merged. The `compound-engineering` plugin ships 37 skills and 51 agents, under an MIT license, and it's built to work off the same manifest across nine different tools: Claude Code, Cursor, Codex, GitHub Copilot CLI, Factory Droid, Qwen Code, OpenCode, Pi and Gemini CLI.

repo       EveryInc/compound-engineering-plugin
stars      ~23,300 · MIT license · authors Kieran Klaassen & Tyler Chow (Every)
what       37 skills + 51 agents installable as a plugin
flow       strategy -> brainstorm -> plan -> work -> review -> learning
harnesses  Claude Code · Cursor · Codex · Copilot CLI · Factory Droid · Qwen · more
extra      persistent STRATEGY.md + periodic reports in docs/pulse-reports/

🧭 The loop: strategy, brainstorm, plan, work, review, learning

The core loop is made of skills that hand off to one another. `/ce-strategy` creates and maintains `STRATEGY.md`, a durable anchor with the product's target problem, approach, persona and metrics: downstream skills read it as grounding. `/ce-ideate` is an optional prelude for when you don't yet know what to build — it generates and critiques bigger ideas before choosing one to carry into brainstorming. `/ce-brainstorm` asks interactive questions to turn a rough idea into a right-sized requirements doc, which `/ce-plan` turns into a detailed implementation plan. `/ce-work` executes the plan with isolated worktrees and task tracking; `/ce-debug` steps in to systematically reproduce a bug and trace it to its root cause.

Two skills close the loop: `/ce-code-review`, a multi-agent review before merging, and `/ce-compound`, which documents what was learned to make future work easier. There's also a piece rarely seen elsewhere: `/ce-product-pulse`, a time-windowed report (24h, 7 days...) on how the product actually behaved in production — errors, performance, real usage — saved to `docs/pulse-reports/`. Past pulse reports become a browsable timeline, and the next strategy update or brainstorm starts from real signal, not just intuition.

⚙️ How to install it: nine harnesses, one source repo

On Claude Code installation is two lines: register the repo's marketplace and install the `compound-engineering` plugin. On Cursor it's just `/add-plugin compound-engineering` from the agent chat. On Codex it takes three steps instead of one: register the marketplace, install the Compound Engineering agents with a Bun command (because Codex's plugin spec doesn't yet register custom agents), and finally activate the plugin from the `/plugins` TUI inside Codex. Copilot CLI, Factory Droid and Qwen Code read the same Claude Code-compatible manifest directly and convert the format automatically — no Bun step needed.

For OpenCode, Pi, Gemini CLI and Kiro the repo ships a Bun/TypeScript installer that converts the plugin into each target's format; they're therefore 'converter-backed' and may change behavior as those formats evolve. Pi in particular needs the extra `pi-subagents` dependency, since it doesn't ship a native subagent primitive that skills can dispatch to. In general, Bun is only needed for converted targets, for the extra Codex step, for local development, and for cleaning up old installs: Claude Code by itself doesn't need it at all.

# Claude Code — the repo's official marketplace
/plugin marketplace add EveryInc/compound-engineering-plugin
/plugin install compound-engineering

# Codex — three steps (marketplace + agents via Bun + TUI install)
codex plugin marketplace add EveryInc/compound-engineering-plugin
bunx @every-env/compound-plugin install compound-engineering --to codex
# then inside Codex: /plugins -> Compound Engineering -> Install

# Cursor
/add-plugin compound-engineering

🏢 Why it's interesting, for developers and SMBs

For developers, the value isn't just installing the plugin: the 37 skills are readable Markdown, and studying them alone is a crash course in structuring a loop with agents — how to write a right-sized requirements doc, how to move from a plan to isolated worktrees, how to close a cycle with a note the next one can reuse. `STRATEGY.md` and the `pulse-reports` are the project's most original idea: they give the agent a memory of what happened, not just instructions on what to do next.

For an SMB using coding agents, the point is predictability: different developers with the same plugin produce work with the same shape — requirements, plan, review, learning note — instead of incompatible prompting styles. Knowledge stops living only in the head of whoever wrote a feature and becomes a versioned artifact, readable by the next cycle and the next teammate. It's the same leap that separates artisanal vibe coding from repeatable agentic engineering, packaged here into a plugin you can install in two commands.

⚠️ What to know before adopting it

The full loop — strategy, brainstorm, plan, work, review, learning — works best on real features, less so on micro-fixes, where it can feel like an oversized process: a one-line change doesn't need the whole cycle. On Codex installation takes three steps instead of one, because the native plugin spec doesn't yet cover the custom agents that skills like `/ce-code-review` and `/ce-plan` depend on — a limitation the project states outright, not a hidden bug.

The project is explicitly opinionated: 37 skills and 51 agents are a large surface to absorb, and the maintainers warn that not every outside proposal will be accepted, since the direction reflects a specific point of view on how agent-assisted engineering should work. The OpenCode, Pi, Gemini CLI and Kiro targets go through a converter installer and aren't native harnesses like Claude Code: they can change behavior as those formats evolve, and Pi additionally needs the external `pi-subagents` dependency.

• Process overhead: the full loop pays off on real features, is overkill on micro-fixes.
• Codex in three steps: marketplace + a Bun step for the agents + TUI install, until Codex's plugin spec supports native agents.
• Large surface: 37 skills and 51 agents are a lot to learn; start with just the core loop.
• Converter-backed targets: OpenCode, Pi, Gemini CLI and Kiro go through a Bun converter and can change over time.

🗺️ Where to start

My suggested path: install the plugin on Claude Code from the official marketplace, open a real feature — not a fix — and let `/ce-brainstorm` genuinely ask its questions before moving to `/ce-plan`, `/ce-work` and `/ce-code-review`. Close the loop with `/ce-compound` and read the note it generates under `docs/solutions/`: that's where you can tell whether the method is actually compounding or just adding ceremony.

If this topic interests you, I've covered it from other angles: Superpowers, another skills framework with the same goal but a different take on the method, hooks as quality gates that complement a loop like this one from the outside, and the cultural leap from vibe coding to agentic engineering that Compound Engineering packages into a plugin installable in two commands. Three different answers to the same question: how do you give repeatable structure to work done with agents.

More articles from the blog