Explosive! The compound-engineering-plugin makes code better and better, rejecting AI technical debt!

It flips resource allocation — 80% goes to planning and review, 20% to execution.

Officially produced by Every, it has reached 20K+ stars on GitHub, perfectly supporting three major platforms: Claude Code, Codex, and Cursor.

Most people’s codebases are like this: the older the project, the more afraid of changes. Each added feature makes the next change slower. Technical debt is not the result of a single instance of laziness; it’s the development rhythm itself continuously producing friction.

The core loop works like this: First use /ce-brainstorm to clarify requirements through interaction /ce-plan to produce an implementation plan /ce-work to execute according to the plan (with worktree and task tracking) /ce-code-review for multi-agent parallel review The last step is the most memorable — /ce-compound, which documents the pitfalls encountered this time, so the next agent can directly gain experience.

The entire plugin includes 37 skills + 51 agents, along with /ce-debug (systematic reproduction, localization, and fix), /ce-strategy (maintain product strategy anchor points), and /ce-product-pulse (generate user usage reports).

Installation is also simple, two commands in Claude Code:

/plugin marketplace add EveryInc/compound-engineering-plugin
/plugin install compound-engineering

GitHub:

EveryInc/compound-engineering-plugin

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

Compound Engineering

Build Status (https://github.com/EveryInc/compound-engineering-plugin/actions/workflows/ci.yml) npm (https://www.npmjs.com/package/@every-env/compound-plugin)

AI skills and agents that make each unit of engineering work easier than the last.

Philosophy

Each unit of engineering work should make subsequent units easier – not harder.

Traditional development accumulates technical debt. Every feature adds complexity. Every bug fix leaves behind a little more local knowledge that someone has to rediscover later. The codebase gets larger, the context gets harder to hold, and the next change becomes slower.

Compound engineering inverts this. 80% is in planning and review, 20% is in execution:

• Plan thoroughly before writing code with /ce-brainstorm and /ce-plan
• Review to catch issues and calibrate judgment with /ce-code-review and /ce-doc-review
• Codify knowledge so it is reusable with /ce-compound
• Keep quality high so future changes are easy

The point is not ceremony. The point is leverage. A good brainstorm makes the plan sharper. A good plan makes execution smaller. A good review catches the pattern, not just the bug. A good compound note means the next agent does not have to learn the same lesson from scratch.

Learn more

• Full component reference - all agents and skills
• Compound engineering: how Every codes with agents (https://every.to/chain-of-thought/compound-engineering-how-every-codes-with-agents)
• The story behind compounding engineering (https://every.to/source-code/my-ai-had-already-fixed-the-code-before-i-saw-it)

Workflow

/ce-strategy is upstream of the loop – it captures the product’s target problem, approach, persona, metrics, and tracks as a short durable anchor at STRATEGY.md. Ideate, brainstorm, and plan read it as grounding when present, so strategy choices flow into feature conception, prioritization, and spec.

The core loop is: brainstorm the requirements, plan the implementation, work through the plan, review the result, compound the learning, then repeat with better context.

Use /ce-ideate before the loop when you want the agent to generate and critique bigger ideas before choosing one to brainstorm. It produces a ranked ideation artifact, not requirements, plans, or code.

/ce-product-pulse is the read-side companion – a time-windowed report on what users actually experienced and how the product performed over a given window (24h, 7d, etc.), saved to docs/pulse-reports/ so past pulses form a browseable timeline of user outcomes. The next strategy update and the next brainstorm get real signal to anchor to.

Each cycle compounds: brainstorms sharpen plans, plans inform future plans, reviews catch more issues, patterns get documented.

Quick Example

A typical cycle starts by turning a rough idea into a requirements doc, then planning from that doc before handing execution to /ce-work:

text /ce-brainstorm "make background job retries safer" /ce-plan docs/brainstorms/background-job-retry-safety-requirements.md /ce-work /ce-code-review /ce-compound

For a focused bug investigation:

text /ce-debug "the checkout webhook sometimes creates duplicate invoices" /ce-code-review /ce-compound

Getting Started

After installing, run /ce-setup in any project. It checks your environment, installs missing tools, and bootstraps project config.

The compound-engineering plugin currently ships 37 skills and 51 agents. See the full component reference for the complete inventory.

Install

Claude Code

text /plugin marketplace add EveryInc/compound-engineering-plugin /plugin install compound-engineering

Cursor

In Cursor Agent chat, install from the plugin marketplace:

text /add-plugin compound-engineering

Or search for “compound engineering” in the plugin marketplace.

Codex

Three steps: register the marketplace, install the agent set, then install the plugin through Codex’s TUI.

1. Register the marketplace with Codex:

   bash codex plugin marketplace add EveryInc/compound-engineering-plugin

2. Install the Compound Engineering agents (Codex’s plugin spec does not register custom agents yet):

   bash bunx @every-env/compound-plugin install compound-engineering --to codex

3. Install the plugin through Codex’s TUI: launch codex, run /plugins, find the Compound Engineering marketplace, select the compound-engineering plugin, and choose Install. Restart Codex after install completes. Codex’s CLI can register marketplaces, but it does not currently expose a plugin-install subcommand for plugins from an added marketplace – the /plugins TUI install is required for CE skills.

All three steps are needed. The marketplace registration plus TUI install handles skills; the Bun step adds the review, research, and workflow agents that skills like $ce-code-review, $ce-plan, and $ce-work spawn in Codex. Without the agent step, delegating skills will report missing agents.

For a non-default Codex profile, run every Codex-related step against the same CODEX_HOME. This example installs CE into a work profile:

bash CODEX_HOME="$HOME/.codex/profiles/work" codex plugin marketplace add EveryInc/compound-engineering-plugin CODEX_HOME="$HOME/.codex/profiles/work" bunx @every-env/compound-plugin install compound-engineering --to codex CODEX_HOME="$HOME/.codex/profiles/work" codex

Inside Codex, run /plugins, select Compound Engineering, then install compound-engineering. The marketplace step only makes the plugin available; the TUI install is what activates the native CE skills for that profile.

For local development from this checkout, register the current worktree and use the local CLI:

bash CODEX_HOME="$HOME/.codex/profiles/work" codex plugin marketplace add "$PWD" CODEX_HOME="$HOME/.codex/profiles/work" bun run src/index.ts install ./plugins/compound-engineering --to codex CODEX_HOME="$HOME/.codex/profiles/work" codex

Heads up: once Codex’s native plugin spec supports custom agents, the Bun agent step goes away. The TUI install alone will be sufficient.

If you previously used the Bun-only Codex install, back up stale CE artifacts before switching:

bash bunx @every-env/compound-plugin cleanup --target codex

GitHub Copilot

For VS Code Copilot Agent Plugins:

1. Run Chat: Install Plugin from Source from the VS Code command palette
2. Use EveryInc/compound-engineering-plugin for the repo
3. Select compound-engineering when VS Code shows the plugins in this repository

For Copilot CLI, use:

Inside Copilot CLI:

text /plugin marketplace add EveryInc/compound-engineering-plugin /plugin install compound-engineering@compound-engineering-plugin

From a shell with the copilot binary:

bash copilot plugin marketplace add EveryInc/compound-engineering-plugin copilot plugin install compound-engineering@compound-engineering-plugin

Copilot CLI reads the existing Claude-compatible plugin manifests, so no separate Bun install step is needed.

If you previously used the old Bun Copilot install, back up stale CE artifacts before switching to the native plugin:

bash bunx @every-env/compound-plugin cleanup --target copilot

Factory Droid

From a shell with the droid binary:

bash droid plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin droid plugin install compound-engineering@compound-engineering-plugin

Droid uses plugin@marketplace plugin IDs; here compound-engineering is the plugin and compound-engineering-plugin is the marketplace name. Droid installs the existing Claude Code-compatible plugin and translates the format automatically, so no Bun install step is needed.

If you previously used the old Bun Droid install, back up stale CE artifacts before switching to the native plugin:

bash bunx @every-env/compound-plugin cleanup --target droid

Qwen Code

bash qwen extensions install EveryInc/compound-engineering-plugin:compound-engineering

Qwen Code installs Claude Code-compatible plugins directly from GitHub and converts the plugin format during install, so no Bun install step is needed.

If you previously used the old Bun Qwen install, back up stale CE artifacts before switching to the native extension:

bash bunx @every-env/compound-plugin cleanup --target qwen

OpenCode, Pi, Gemini, and Kiro

This repo includes a Bun/TypeScript installer that converts the Compound Engineering plugin to OpenCode, Pi, Gemini CLI, and Kiro CLI.

bash bunx @every-env/compound-plugin install compound-engineering --to opencode bunx @every-env/compound-plugin install compound-engineering --to pi bunx @every-env/compound-plugin install compound-engineering --to gemini bunx @every-env/compound-plugin install compound-engineering --to kiro

Pi prerequisites. Pi does not ship a native subagent primitive, so the Pi install depends on nicobailon/pi-subagents (https://github.com/nicobailon/pi-subagents) (required) and recommends edlsh/pi-ask-user (https://github.com/edlsh/pi-ask-user) for richer blocking user questions:

bash pi install npm:pi-subagents # required — provides the `subagent` tool used by skills that dispatch parallel agents pi install npm:pi-ask-user # recommended — provides the `ask_user` tool; skills fall back to numbered options in chat when it is missing

To auto-detect custom-install targets and install to all:

bash bunx @every-env/compound-plugin install compound-engineering --to all

The custom install targets run CE legacy cleanup during install. To run cleanup manually for a specific target:

bash bunx @every-env/compound-plugin cleanup --target codex bunx @every-env/compound-plugin cleanup --target opencode bunx @every-env/compound-plugin cleanup --target pi bunx @every-env/compound-plugin cleanup --target gemini bunx @every-env/compound-plugin cleanup --target kiro bunx @every-env/compound-plugin cleanup --target copilot # old Bun installs only bunx @every-env/compound-plugin cleanup --target droid # old Bun installs only bunx @every-env/compound-plugin cleanup --target qwen # old Bun installs only bunx @every-env/compound-plugin cleanup --target windsurf # deprecated legacy installs only

Cleanup moves known CE artifacts into a compound-engineering/legacy-backup/ directory under the target root.

Local Development

bash bun install bun test bun run release:validate

From your local checkout

For active development – edits to the plugin source are reflected immediately.

Claude Code – add a shell alias so your local copy loads alongside your normal plugins:

bash alias cce='claude --plugin-dir ~/Code/compound-engineering-plugin/plugins/compound-engineering'

Run cce instead of claude to test your changes. Your production install stays untouched.

Codex and other targets – run the local CLI against your checkout:

``bash

from the repo root

bun run src/index.ts install ./plugins/compound-engineering –to codex

same pattern for other targets

bun run src/index.ts install ./plugins/compound-engineering –to opencode ``

From a pushed branch

For testing someone else’s branch or your own branch from a worktree, without switching checkouts. Uses --branch to clone the branch to a deterministic cache directory.

Unpushed local branches: If the branch exists only in a local worktree and has not been pushed, point --plugin-dir directly at the worktree path instead (e.g. claude --plugin-dir /path/to/worktree/plugins/compound-engineering).

Claude Code – use plugin-path to get the cached clone path:

``bash

from the repo root

bun run src/index.ts plugin-path compound-engineering –branch feat/new-agents

Output:

claude –plugin-dir ~/.cache/compound-engineering/branches/compound-engineering-feat~new-agents/plugins/compound-engineering

``

The cache path is deterministic. Re-running updates the checkout to the latest commit on that branch.

Codex, OpenCode, and other targets – pass --branch to install:

``bash

from the repo root

bun run src/index.ts install compound-engineering –to codex –branch feat/new-agents

works with any target

bun run src/index.ts install compound-engineering –to opencode –branch feat/new-agents

combine with –also for multiple targets

bun run src/index.ts install compound-engineering –to codex –also opencode –branch feat/new-agents ``

Both features use the COMPOUND_PLUGIN_GITHUB_SOURCE env var to resolve the repository, defaulting to https://github.com/EveryInc/compound-engineering-plugin.

Shell aliases

Add to ~/.zshrc or ~/.bashrc. All aliases use the local CLI so there is no dependency on npm publishing. plugin-path prints just the path to stdout, so it composes with $().

``bash CE_REPO=~/Code/compound-engineering-plugin

ce-cli() { bun run “CE_REPO/src/index.ts" "@”; }

— Local checkout (active development) —

alias cce=‘claude –plugin-dir $CE_REPO/plugins/compound-engineering’

codex-ce() { ce-cli install “CE_REPO/plugins/compound-engineering" --to codex "@” }

— Pushed branch (testing PRs, worktree workflows) —

ccb() { claude –plugin-dir “(ce-cli plugin-path compound-engineering --branch "1”)“ “${@:2}” }

codex-ceb() { ce-cli install compound-engineering –to codex –branch “1" "{@:2}” } ``

Usage:

bash cce # local checkout with Claude Code codex-ce # install local checkout to Codex ccb feat/new-agents # test a pushed branch with Claude Code ccb feat/new-agents --verbose # extra flags forwarded to claude codex-ceb feat/new-agents # install a pushed branch to Codex

Codex installs keep generated plugin skills isolated under ~/.codex/skills/compound-engineering/ and do not write new files into ~/.agents. The installer removes old CE-managed .agents/skills symlinks when it can prove they point back to CE’s Codex-managed store, which prevents stale Codex installs from shadowing Copilot’s nati