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.

The Core Idea

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 Workflow Loop

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.

Installation

Claude Code (simplest path)

/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.

Cursor

In Cursor Agent chat:

/add-plugin compound-engineering

Or search for "compound engineering" in the plugin marketplace.

GitHub Copilot (VS Code)

1. Open the VS Code command palette
2. Run Chat: Install Plugin from Source
3. Enter EveryInc/compound-engineering-plugin as the repo
4. Select compound-engineering when VS Code shows the available plugins

Codex (three steps required)

Codex 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.

# Step 1: Register the marketplace
codex plugin marketplace add EveryInc/compound-engineering-plugin

# Step 2: Install the agents via Bun
bunx @every-env/compound-plugin install compound-engineering --to codex

# Step 3: Launch Codex, run /plugins, find Compound Engineering, and install
codex

All three steps are required. Skipping the Bun step means delegation-based skills will report missing agents.

Gemini CLI, OpenCode, Kiro, Pi

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

A Typical Bug Investigation

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.

What Actually Gets Written to Disk

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
• Compound notes written by /ce-compound, stored wherever the plugin is configured to put them

These 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.

Is It Worth Using?

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:

• You're working on a non-trivial codebase where decisions have history and context matters
• You find yourself re-explaining the same architectural constraints to your agent in every session
• You want more structured reviews than just "does this code work"
• You're using Claude Code, Cursor, or Copilot and want a workflow rather than just a chat interface

It may be overkill if:

• You're working on small, self-contained scripts or prototypes
• Your sessions are isolated enough that accumulated context doesn't matter
• You prefer a lighter workflow and the brainstorm/plan/compound ceremony feels like friction

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.

Quick Reference

GitHub: https://github.com/EveryInc/compound-engineering-plugin