Every unit of work should make the next one easier
Traditional development compounds the wrong way. Every feature adds complexity, every bug fix leaves behind tribal knowledge someone has to rediscover, and the next change gets slower. Compound Engineering, built by the team at Every, inverts that curve: plan hard, review hard, and codify what you learn, so the codebase and the agents working on it get smarter with every cycle instead of dumber.
- Tech debt curve: each change makes the next one harder.
- Compounding curve: each change banks knowledge for the next.
- Ships as a plugin: 38+ skills and 50+ agents, MIT licensed.
Brainstorm, plan, work, review, compound. Repeat.
Everything hangs on one loop. Brainstorm the requirements until they are right-sized. Plan the implementation in detail. Work the plan with worktrees and task tracking. Review the result with a swarm of specialist agents. Then compound: write the lesson down so no agent ever has to learn it twice. Each pass around the loop starts with better context than the last.
- 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 teaches every future agent.
/ce-brainstorm "make background job retries safer"
/ce-plan docs/brainstorms/background-job-retry-safety-requirements.md
/ce-work
/ce-code-review
/ce-compound/ce-debug "the checkout webhook sometimes creates duplicate invoices"
/ce-code-review
/ce-compound80% planning and review, 20% execution
This is the ratio that makes the whole thing work. When the thinking happens up front, the typing is the easy part: execution shrinks to a small, well-scoped diff that an agent can one-shot. Skimp on the front and the back explodes into re-prompts, rework, and review fights. Spend the effort where it compounds.
- Plan thoroughly before any code with brainstorm + plan.
- Review to catch issues AND calibrate judgment over time.
- Execution is deliberately the smallest slice of the pie.
Strategy anchors the loop. Pulse closes it.
Two pieces sit outside the loop and keep it honest. Upstream, /ce-strategy writes STRATEGY.md: the product's target problem, persona, approach, and metrics. Ideation, brainstorms, and plans all read it as grounding, so strategy flows into every spec. Downstream, /ce-product-pulse generates a time-windowed report on what users actually experienced: usage, errors, performance. The next strategy update gets real signal, not vibes.
- STRATEGY.md is a short, durable anchor the loop reads.
- Pulse reports save to docs/pulse-reports/ as a timeline.
- Optional /ce-ideate generates and ranks big ideas first.
/ce-strategy/ce-product-pulse 7dBrainstorm asks. Plan specs. Work executes.
/ce-brainstorm runs an interactive Q&A until a rough idea becomes a right-sized requirements doc. /ce-plan turns that doc into a detailed implementation plan with automatic confidence checking. /ce-work executes the plan systematically with git worktrees and task tracking. Each artifact feeds the next, and every one is a file you can read, version, and reuse.
- Brainstorm output: a requirements doc, not code.
- Plan works for anything multi-step, not just software.
- Work runs in worktrees so parallel jobs never collide.
/ce-brainstorm "[YOUR FEATURE OR PROBLEM]"/ce-plan docs/brainstorms/[YOUR-DOC]-requirements.md/ce-workReview by a swarm, not a single rubber stamp
/ce-code-review dispatches tiered persona agents in parallel: correctness, security, performance, data integrity, maintainability, an adversarial reviewer that actively tries to break the change, and more. Twenty reviewer personas in all, with confidence gating and a dedup pipeline so you get a ranked list of real issues instead of twenty walls of noise. /ce-doc-review does the same for plans and documents before any code exists.
- 20 code reviewer personas + 7 document review lenses.
- Confidence gating filters out low-certainty nitpicks.
- Reviews calibrate over time: catch the pattern, not the bug.
/ce-code-review/ce-doc-review docs/plans/[YOUR-PLAN].md/ce-resolve-pr-feedbackCompound: write the lesson down, never relearn it
This is the skill the whole system is named after. After a problem is solved, /ce-compound documents the learning in a structured, agent-readable note: what happened, why, and what to do next time. Future brainstorms, plans, and reviews search these learnings automatically. And because knowledge rots, /ce-compound-refresh periodically decides whether each learning should be kept, updated, replaced, or archived.
- Learnings are files agents search, not tribal memory.
- A learnings-researcher agent feeds them into every plan.
- Refresh keeps the knowledge base from going stale.
/ce-compound/ce-compound-refreshInstall it, set it up, let it rip
In Claude Code it is two commands: add the marketplace, install the plugin. Then run /ce-setup in any project and it diagnoses your environment, installs missing tools, and bootstraps config. It also installs to Codex, Cursor, Copilot, Droid, Qwen, Gemini, and more. When you trust the loop, /lfg runs the full autonomous workflow end to end.
- 1. Add the marketplace and install the plugin.
- 2. Run /ce-setup once per project.
- 3. Start the loop with /ce-brainstorm. Or /lfg and hold on.
/plugin marketplace add EveryInc/compound-engineering-plugin
/plugin install compound-engineering/ce-setup/lfg