Compound Engineering Slim Edition

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

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
• The story behind compounding engineering

Why this fork

This is a deliberately slimmed fork of EveryInc/compound-engineering-plugin. What makes it distinct is that removals here are intentional, registered, and swept on upgrade: deleted skills, agents, and commands are recorded in three legacy-cleanup registries (across src/utils/legacy-cleanup.ts and src/data/plugin-legacy-artifacts.ts) so stale flat-install artifacts get removed when users upgrade. It is efficient strictly in the surface-area sense -- fewer components mean a smaller install and a smaller prompt surface -- while keeping the same core workflow.

	this fork	upstream (as of June 2026)
skills	16	39
agents	16	43
converter targets	5 (opencode, codex, pi, gemini, kiro)	more (copilot and droid dropped here)
bundled plugins	1	2 (coding-tutor removed here)

• Removals are tracked in three legacy-cleanup registries so upgrades sweep stale artifacts off users' machines.
• The same brainstorm -> plan -> work -> review -> compound core workflow is preserved.

How is this different from upstream compound-engineering? This is a slimmed fork of EveryInc/compound-engineering-plugin. As of June 2026, it ships 16 skills and 16 agents versus upstream's 39 skills and 43 agents, and 5 converter targets (opencode, codex, pi, gemini, kiro) versus upstream's larger set. The core brainstorm -> plan -> work -> review -> compound workflow is unchanged; removals are registered and swept on upgrade rather than left as orphans.

Workflow

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.

Skill	Purpose
/ce-brainstorm	Interactive Q&A to think through a feature or problem and write a right-sized requirements doc before planning
/ce-plan	Turn feature ideas into detailed implementation plans
/ce-work	Execute plans with worktrees and task tracking
/ce-debug	Systematically reproduce failures, trace root cause, and implement fixes
/ce-code-review	Multi-agent code review before merging
/ce-compound	Document learnings to make future work easier

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:

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

/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 ships 16 skills and 16 agents. See the full component reference for the complete inventory.

---

Install

Claude Code

/plugin marketplace add OutlineDriven/compound-engineering-slim
/plugin install compound-engineering

Cursor

In Cursor Agent chat, install from the plugin marketplace:

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

   codex plugin marketplace add OutlineDriven/compound-engineering-slim

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

   bunx github:OutlineDriven/compound-engineering-slim 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:

CODEX_HOME="$HOME/.codex/profiles/work" codex plugin marketplace add OutlineDriven/compound-engineering-slim
CODEX_HOME="$HOME/.codex/profiles/work" bunx github:OutlineDriven/compound-engineering-slim 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:

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:

bunx github:OutlineDriven/compound-engineering-slim cleanup --target codex

Qwen Code

qwen extensions install OutlineDriven/compound-engineering-slim: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:

bunx github:OutlineDriven/compound-engineering-slim 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.

bunx github:OutlineDriven/compound-engineering-slim install compound-engineering --to opencode
bunx github:OutlineDriven/compound-engineering-slim install compound-engineering --to pi
bunx github:OutlineDriven/compound-engineering-slim install compound-engineering --to gemini
bunx github:OutlineDriven/compound-engineering-slim install compound-engineering --to kiro

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

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:

bunx github:OutlineDriven/compound-engineering-slim install compound-engineering --to all

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

bunx github:OutlineDriven/compound-engineering-slim cleanup --target codex
bunx github:OutlineDriven/compound-engineering-slim cleanup --target opencode
bunx github:OutlineDriven/compound-engineering-slim cleanup --target pi
bunx github:OutlineDriven/compound-engineering-slim cleanup --target gemini
bunx github:OutlineDriven/compound-engineering-slim cleanup --target kiro
bunx github:OutlineDriven/compound-engineering-slim cleanup --target qwen      # old Bun installs only
bunx github:OutlineDriven/compound-engineering-slim 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

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:

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:

# 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:

# 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:

# 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/OutlineDriven/compound-engineering-slim.

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 $().

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:

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 native plugin install.

Troubleshooting

Codex skills work but review or research delegation fails

Run the agent install step:

bunx github:OutlineDriven/compound-engineering-slim install compound-engineering --to codex

Native Codex plugin install handles skills. The Bun step installs the custom agents those skills delegate to.

Codex shows stale or duplicate CE skills

Back up old Bun-installed artifacts before switching to the native Codex plugin flow:

bunx github:OutlineDriven/compound-engineering-slim cleanup --target codex

Qwen loads stale CE skills

Back up old Bun-installed artifacts before using the native plugin path:

bunx github:OutlineDriven/compound-engineering-slim cleanup --target qwen

Limitations

Codex native plugin install currently handles skills, not custom agents. The documented Bun followup is required until Codex supports agents in its native plugin spec.

OpenCode, Pi, Gemini, and Kiro installs are converter-backed and may change as those target formats evolve.

Release versions are owned by release automation. Routine feature PRs should not hand-bump plugin or marketplace manifest versions.

FAQ

Do I need Bun for Claude Code?

No. Claude Code installs directly from the plugin marketplace. Bun is only needed for converter-backed targets, Codex's current agent followup, local development, and cleanup of old converted installs.

Why does Codex need a separate Bun step?

Codex's native plugin flow installs skills from the Codex plugin manifest. It does not currently install the custom reviewer, researcher, and workflow agents that Compound Engineering skills delegate to. The Bun step fills that gap.

Where do I see all available skills and agents?

Read the Compound Engineering plugin README. It lists the current skill and agent inventory.

Where is release history?

GitHub Releases are the canonical release-notes surface. The root CHANGELOG.md points to that history.

Contributing

Contributions are welcome. Issues, bug reports, and pull requests all help make this better, and we genuinely appreciate them — bug reports especially.

A note on what to expect: Compound Engineering is opinionated by design. It's maintained by @kieranklaassen and @tmchow, and its direction reflects a specific point of view about how AI-assisted engineering should work. So while we welcome help, we can't promise to accept every change — some proposals won't fit that vision even when they're good ideas on their own.

Open an issue or send a PR, and we'll fold in what moves the plugin in the right direction. We just want to be upfront that not everything will land.

License

MIT