Most developers using AI coding tools hit the same ceiling eventually. The agent writes code, you accept or reject it, and next time it starts from scratch again. There's no memory of what worked, no accumulated judgment about your codebase, no improvement from one session to the next. You're getting faster, but the tool isn't getting better at helping you specifically.
Compound Engineering is a plugin that tries to fix that. Built by Every.to and available for Claude Code, Cursor, Codex, GitHub Copilot, and a growing list of other tools, it introduces a structured workflow designed around a simple principle: each unit of engineering work should make the next one easier.
Traditional development accumulates technical debt. Features add complexity, bug fixes leave behind knowledge no one wrote down, and the codebase slowly becomes harder to change.
The Compound Engineering philosophy inverts the ratio: 80% of the effort goes into planning and review, 20% into execution. The thinking is that a sharp plan produces a smaller, cleaner implementation. A good code review catches a pattern, not just a specific bug. A documented learning means the agent doesn't have to rediscover the same constraint next week.
The plugin ships 37 skills and 51 agents that implement this workflow as slash commands you run inside your AI coding tool.
The core loop looks like this:
/ce-brainstorm "add retry logic to background jobs"
/ce-plan docs/brainstorms/background-job-retry-requirements.md
/ce-work
/ce-code-review
/ce-compound
Here's what each step actually does:
** /ce-brainstorm** runs an interactive Q&A session. It asks clarifying questions about your feature or problem, then produces a right-sized requirements document. The output is a file you can hand directly to the next step.
** /ce-plan** takes that requirements document and turns it into a detailed implementation plan: what to change, what to test, what the edge cases are.
** /ce-work** executes the plan. It uses worktrees for isolation and tracks tasks as it goes.
** /ce-code-review** is a multi-agent review pass before you merge. It looks for issues but, more importantly, tries to catch patterns — recurring problems that are worth documenting rather than just fixing.
** /ce-compound** is where the compounding happens. It documents the learnings from this cycle so the agent has better context the next time you work on something similar.
There are also two commands that sit outside the core loop:
** /ce-strategy** creates and maintains a
STRATEGY.md
file — the product's target problem, approach, personas, and key metrics. When this file exists, brainstorm and plan commands read it as grounding, so your strategy choices flow naturally into feature decisions.** /ce-ideate** sits upstream of brainstorm for bigger questions. Instead of jumping into requirements, it generates and critically evaluates several ideas, then routes the strongest one into the brainstorm step.
** /ce-debug** is for bug investigations. It systematically reproduces the failure, traces the root cause, and implements a fix rather than just patching the symptom.
** /ce-product-pulse** generates a time-windowed report on usage, performance, and errors. Reports are saved to
docs/pulse-reports/
so they accumulate into a browseable history of how the product is actually performing.
/plugin marketplace add EveryInc/compound-engineering-plugin
/plugin install compound-engineering
No Bun required. After installing, run /ce-setup
to check your environment and bootstrap project config.
In Cursor Agent chat:
/add-plugin compound-engineering
Or search for "compound engineering" in the plugin marketplace.
Chat: Install Plugin from Source
EveryInc/compound-engineering-plugin
as the repocompound-engineering
when VS Code shows the available pluginsCodex currently needs an extra step because its native plugin spec handles skills but not custom agents. The agents are what power commands like /ce-code-review
and /ce-plan
.
codex plugin marketplace add EveryInc/compound-engineering-plugin
bunx @every-env/compound-plugin install compound-engineering --to codex
codex
All three steps are required. Skipping the Bun step means delegation-based skills will report missing agents.
bunx @every-env/compound-plugin install compound-engineering --to gemini
bunx @every-env/compound-plugin install compound-engineering --to opencode
bunx @every-env/compound-plugin install compound-engineering --to kiro
bunx @every-env/compound-plugin install compound-engineering --to pi
For debugging, the flow is shorter:
/ce-debug "checkout webhook sometimes creates duplicate invoices"
/ce-code-review
/ce-compound
/ce-debug
doesn't just jump to a fix. It reproduces the failure first, traces where it originates, then implements a targeted fix. After a review and a compound step, that knowledge about the invoicing edge case is now part of the project's accumulated context.
This is worth understanding. Compound Engineering is not just about prompts — it produces files in your project:
STRATEGY.md
— the product anchor document, if you use /ce-strategy
docs/brainstorms/
— requirements documents from /ce-brainstorm
docs/pulse-reports/
— product performance reports from /ce-product-pulse
/ce-compound
, stored wherever the plugin is configured to put themThese files are meant to persist across sessions and become grounding context for future agent interactions. The point is that each cycle is building toward a more informed next cycle, not starting fresh.
The plugin is a genuine attempt to solve a real problem: AI coding agents are stateless by default, and their usefulness degrades over the life of a complex project unless you actively manage context.
It's worth trying if:
It may be overkill if:
The contribution policy is also worth knowing: the author explicitly does not accept outside contributions and reviews issues and PRs through their own agents rather than directly. That's an unusual choice for an open-source tool, but it's stated clearly and the release cadence (153 releases, latest in May 2026) suggests active maintenance regardless.
One honest note: the value of this plugin scales with how consistently you run the full loop. If you only use /ce-work
and skip /ce-compound
, you're leaving the most important part on the table. The compounding only happens if you complete the cycle.
| Command | What it does |
|---|---|
/ce-setup |
|
| First-time setup and environment check | |
/ce-strategy |
|
Create or update STRATEGY.md |
|
/ce-ideate |
|
| Big-picture ideation before brainstorming | |
/ce-brainstorm |
|
| Interactive requirements doc generation | |
/ce-plan |
|
| Turn requirements into an implementation plan | |
/ce-work |
|
| Execute the plan | |
/ce-debug |
|
| Reproduce, trace, and fix a bug | |
/ce-code-review |
|
| Multi-agent pre-merge review | |
/ce-doc-review |
|
| Documentation review | |
/ce-compound |
|
| Document learnings for future sessions | |
/ce-product-pulse |
|
| Time-windowed usage and error report |
GitHub: https://github.com/EveryInc/compound-engineering-plugin