Compound engineering vs Superpowers: what each one installs

Last updated: August 27, 2026

TL;DR

Superpowers is a craft library that loads itself into every session through a SessionStart hook. Compound engineering is a lifecycle system you invoke by name, and it is the only one of the two that writes knowledge back to disk between sessions. They overlap on six skills. They are not mutually exclusive, and most repos should run both.

Here is what that looks like when you actually install them.

What each one is, measured

Both plugins are installed on the machine this post was written on. These numbers come from the plugin cache, not from the READMEs, and both are open source if you want to count them yourself: obra/superpowers and EveryInc/compound-engineering-plugin.

Two numbers there decide almost everything else.

298 reference files against 25. Compound engineering keeps its depth in files a skill pulls in only when it needs them: ce-plan alone carries 33, ce-code-review carries 31. Superpowers keeps almost everything in the skill body itself. That is why superpowers has more instruction per skill (1,482 words each on average, against 1,033) while compound engineering has far more total material available.

One hook against none. This is the difference nobody writing about these plugins mentions, and it is the one you feel first.

The SessionStart hook is the real difference

Superpowers ships a single hook. On session start, clear, or compact, it reads skills/using-superpowers/SKILL.md and injects the whole file into the session as context.

The practical effect: superpowers is always on. Every session opens already carrying its rule, which is that you must invoke a matching skill before responding to anything, including a clarifying question. Nobody types a command. The plugin puts itself in the room.

Compound engineering has no hooks at all. Its 33 skills sit inert until something invokes one by name, whether that is you typing /ce-plan or an AGENTS.md that names the pipeline.

So the two plugins answer different questions:

• Superpowers answers "how do I keep the agent from skipping steps?" by making its methodology unavoidable.
• Compound engineering answers "what does this repo do, in what order?" by giving you named stages to invoke.

One is ambient discipline. The other is an explicit pipeline. That is a design choice, not a quality difference.

Where the two collide

Six capabilities exist in both plugins:

Install both and every one of those is a fork in the road. Since superpowers' hook fires first and instructs the agent to invoke a matching skill immediately, its version tends to win by default unless your repo instructions say otherwise.

That is fixable in one line of AGENTS.md, and it is the single most important thing to get right when running both. Name which plugin owns the spine, and the collisions stop being ambiguous.

What only superpowers has

Strip out the overlap and superpowers is a craft library:

• test-driven-development – compound engineering has no TDD skill at all
• verification-before-completion – checks the work is actually done before claiming it is
• subagent-driven-development and dispatching-parallel-agents – multi-agent execution patterns
• writing-skills – how to author new skills
• receiving-code-review – the other half of a review, which is rarer than it sounds
• finishing-a-development-branch

The centre of gravity is how to do engineering work well inside one session. Its brainstorming skill is the clearest example: it classifies every request as a spike, a bounded change, or architectural work, then applies a hard gate. No implementation of any kind until you have approved the design, and the classification only ever ratchets upward when hidden complexity appears.

What only compound engineering has

Strip out the overlap and compound engineering is a lifecycle system. It covers three areas superpowers does not touch:

The shipping tail. ce-commit, ce-commit-push-pr, ce-resolve-pr-feedback, and ce-babysit-pr, which watches an open pull request until it is merge-ready. Superpowers stops at a finished branch.

Memory between sessions. ce-compound writes a solved problem to docs/solutions/<category>/<slug>.md, and ce-compound-refresh prunes those entries when the code moves underneath them. This is the plugin's namesake and it has no counterpart in superpowers. It is also the reason the comparison is not symmetric: one plugin makes a session better, the other makes the next session better.

Work above the code. ce-strategy, ce-product-pulse, ce-ideate, ce-optimize, ce-pov, ce-handoff, ce-doc-review. These fire occasionally rather than per change, and they are about deciding what to build and preserving why.

Running both: what actually happens

The setup that works here is Compound Engineering for Claude Code driven by AGENTS.md: compound engineering is named as the spine of every change, and superpowers runs underneath it. That division holds up in practice for one reason: the plugins fail in opposite directions.

Superpowers' failure mode is ceremony. A one-line copy fix still gets classified, and the hard gate still asks for approval before an edit. Its own docs anticipate this and scale the artifact down, but never the approval.

Compound engineering's failure mode is drift. Nothing fires unless invoked, so the compounding step is the first thing to get skipped, and a knowledge store nobody writes to is just an empty directory.

Put together, each covers the other's gap. Superpowers stops work from starting sloppily. Compound engineering stops work from ending unrecorded.

Where the two overlap on a single named job, it is worth reading the specific comparison rather than reasoning from the general one. The review skills are the clearest case, and Claude Code's /code-review vs /ce-code-review goes through that pair in detail.

What the always-on hook actually costs

A recurring worry on Hacker News is that superpowers is token-hungry. Measured, the always-on part is not: the file its hook injects is 777 tokens, about 0.4% of a 200k context window, and it fires on startup, clear, and compact.

The cost arrives when a skill actually loads. subagent-driven-development is roughly 8,084 tokens, writing-skills 6,590, brainstorming 3,864 – that last one alone is five times the hook. Compound engineering's heaviest skills are smaller (ce-debug at 3,650, ce-explain at 2,780, ce-plan at 1,970) because its depth sits in 298 reference files a skill pulls only when it needs them.

So the honest framing is the reverse of the worry. Superpowers costs almost nothing to have installed and a real amount every time it decides a skill applies, which on its own rule is constantly. Compound engineering costs nothing until you invoke it, then loads less per invocation. If you are already managing a tight Claude Code context window, that difference compounds across a long session.

Which one to install

Installing them

Superpowers is in Anthropic's official marketplace, so it is one command:

/plugin install superpowers@claude-plugins-official

Compound engineering needs its marketplace added first, and skipping this step is why a plain /plugin search does not find it:

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

/ce-setup checks for gh, jq, and the other CLI tools its skills expect, then writes a local config.

The honest verdict

The versions matter here. Compound engineering is on 3.23.4 and superpowers on 6.3.0, both moving fast enough that any specific skill list ages in weeks. What is unlikely to change is the shape: superpowers is ambient and craft-focused, compound engineering is invoked and lifecycle-focused, and only one of them writes anything down for next time.

If you can only run one and you already have working habits, take superpowers. If you keep answering questions your past self already answered, take compound engineering.

FAQ

What do Superpowers do in Claude Code?

Superpowers installs 14 skills covering brainstorming, planning, test-driven development, systematic debugging, code review, and worktrees. A SessionStart hook injects its top-level rule into every session, so the agent is instructed to invoke a matching skill before it responds to anything.

How do I use Superpowers in Claude Code?

Run /plugin install superpowers@claude-plugins-official. There is nothing else to configure. The SessionStart hook loads its instructions on every new session, clear, and compact, and the agent invokes individual skills on its own when a task matches one.

Is the Claude Code Superpowers plugin worth it?

It is worth it if your agent skips steps: starting to code before a design is agreed, declaring work done without verifying, or debugging by guesswork. Those are exactly the three failures its hard gates target. If you already work that way by habit, it mostly adds ceremony.

What are the skill Superpowers in Claude Code?

The 14 are: using-superpowers, brainstorming, writing-plans, executing-plans, subagent-driven-development, dispatching-parallel-agents, test-driven-development, systematic-debugging, requesting-code-review, receiving-code-review, verification-before-completion, using-git-worktrees, finishing-a-development-branch, and writing-skills.

What is compound engineering in AI?

Compound engineering is a development approach where every task leaves the environment better for the next one. Instead of starting each AI session from scratch, solved problems, decisions, and corrections get written back into files the agent reads next time, so the system gets faster rather than more tangled.

What is a compound engineer?

In this context, someone who spends most of their effort on planning, review, and capturing what was learned, and comparatively little typing code. The work shifts toward judgment and system design, with agents handling execution against specifications the engineer defines.

Can you run Superpowers and compound engineering together?

Yes, and it is the common setup. Six capabilities overlap, so name one plugin as the spine in AGENTS.md and let the other fill its gaps. Without that line, superpowers usually wins the collisions by default because its hook fires at session start.

Does Superpowers use a lot of tokens?

The always-on part does not: its SessionStart hook injects about 777 tokens, roughly 0.4% of a 200k window. The cost comes from individual skills loading, where subagent-driven-development runs about 8,084 tokens and brainstorming about 3,864.

Which plugin has more skills?

Compound engineering, with 33 skills against 14, plus 298 supporting reference files against 25. Superpowers carries more instruction inside each individual skill.

Does compound engineering include TDD?

No. There is no test-driven-development skill in compound engineering 3.23.4. It ships ce-test-browser and ce-test-xcode for browser and Xcode testing, but the TDD discipline itself lives only in superpowers.

Which one keeps knowledge between sessions?

Only compound engineering. ce-compound writes solved problems to docs/solutions/ and ce-compound-refresh prunes stale entries. Superpowers has no equivalent, so nothing it does survives the session that did it.