Superpowers vs Claude Code Agent Teams: methodology or orchestration?

When parallel Claude Code agents start causing problems, two tools come up in the same breath: Superpowers and Agent Teams. Both address the chaos of running multiple agents. Neither does what the other does. If you're evaluating both, the decision is simpler than it looks: they target different failure modes, and for most teams the question isn't which one to pick but which problem you're actually solving.

What Superpowers is

Superpowers is an open-source skills framework created by Jesse Vincent (obra). It ships as a folder of markdown files that encode an opinionated engineering methodology into Claude Code's behavior. The framework is available in the Anthropic Claude Code plugin marketplace and works across Claude Code, Cursor, Codex, Gemini CLI, and other AI coding environments that support CLAUDE.md-style context files.

The core framework bundles 14+ skills that together enforce a 7-phase workflow: Brainstorm, Spec, Plan, TDD, Subagent Development, Review, and Finalize. The skills chain together: an agent using Superpowers brainstorms before it writes a line of code, specifies the work before planning, follows strict TDD (failing test first, implementation second), runs a subagent review pass before finalizing, and verifies before marking completion.

The underlying bet is simple: AI coding agents are not missing capability. They're missing discipline. Superpowers encodes that discipline as plain text, so any Claude Code-compatible agent inherits it by having the files in context.

Superpowers operates entirely within a single agent's context window. It shapes how that one agent thinks, sequences its work, and gates its output. It says nothing about running multiple agents, parallelizing tasks, or coordinating across sessions.

What Claude Code Agent Teams is

Claude Code Agent Teams is an Anthropic-native feature that runs multiple full Claude Code instances in parallel, each with its own context window, coordinated through a shared task list and direct messaging. It shipped as an experimental feature in February 2026.

The coordination model: one lead agent breaks work into tasks and assigns them. Teammate agents claim pending tasks, mark them in progress, and complete them. Agents message each other directly when an assumption changes, a cross-module dependency surfaces, or a shared interface needs renegotiation. The shared task list is the coordination primitive; git worktrees provide isolation so agents can work in parallel without stepping on each other's files.

Agent Teams runs on top of your existing Claude plan. Pro, Max, or Team subscribers use the same token quota, but parallel sessions consume it proportionally: three agents running simultaneously draw from the quota three times as fast. There is no separate pricing tier for Agent Teams.

The bet: some work is genuinely parallel, and running it sequentially wastes wall-clock time. Agent Teams gives you the coordination layer to split that work across multiple agents that can actually communicate rather than running blind in separate terminals.

The core difference

Superpowers and Agent Teams do not compete. They operate at different levels of the problem.

Superpowers governs how a single agent thinks. It enforces methodology within a context window: think before you code, test before you implement, review before you ship. It has no model of how many agents are running, what tasks they're assigned, or how they coordinate.

Agent Teams governs how multiple agents are organized. It handles task assignment, inter-agent communication, and parallel execution across context windows. It has no opinion on how any individual agent should approach its task: whether it follows TDD, whether it reviews its own work, whether it brainstorms before writing.

These are different problems:

• Quality problem: "My agents ship untested code, make assumptions they shouldn't, and skip review." Superpowers addresses this.
• Throughput problem: "I have five independent tasks and running them sequentially takes too long." Agent Teams addresses this.

Where Superpowers is the right call

Reach for Superpowers when the failure mode is output quality rather than output volume. If your agents skip tests, make design leaps without validation, or commit without reviewing what they changed, adding more agents via Agent Teams will multiply the problem. More agents running fast and loose produces more fast-and-loose code.

Superpowers is also the right call when you want platform-portable methodology. Because it runs as markdown in any CLAUDE.md-compatible environment, it travels with your project regardless of which AI coding tool you use. A team that switches from Claude Code to Codex next quarter keeps the same methodology.

It's well-suited to complex single-task work: a greenfield feature with real design surface area, a refactor that touches multiple modules, a new service where the architecture decision matters more than the delivery speed. The brainstorm-spec-plan sequence earns its overhead on tasks where the upfront thinking materially reduces rework.

Where Agent Teams is the right call

Reach for Agent Teams when you have separable, parallel work and sequential execution is the actual constraint. Independent modules, parallel QA across platforms, simultaneous work on separate services, or a large migration where tasks can be cleanly divided: these are where Agent Teams earns its cost. Running ten isolated tasks sequentially when eight could run in parallel is leaving real time on the floor.

Agent Teams is also useful when you need cross-agent awareness during execution. Unlike running multiple Claude Code sessions manually in separate terminals, Agent Teams gives teammates a way to surface interface conflicts and shared assumptions in real time rather than at merge time. The direct messaging between agents is a genuine improvement over blind parallel execution.

Note the cost model: parallel sessions consume your Claude plan quota proportionally. At Max 5x ($100/month), running five parallel agents burns your monthly allowance five times faster than a single session. This is not a hidden fee, but it is a real constraint if your workload is sustained rather than bursty.

Can you use both?

Yes. Superpowers and Agent Teams operate at different layers, so they compose without conflict.

A Superpowers-conditioned agent can participate in an Agent Team. If the CLAUDE.md files encoding the Superpowers skills are in the repo each teammate clones, each agent inherits the methodology. You get parallel execution (Agent Teams) and per-agent discipline (Superpowers) simultaneously.

The catch: Agent Teams does not enforce that individual teammates use Superpowers. There is no Agent Teams configuration that says "each spawned teammate must complete the brainstorm and spec phases before implementing." You rely on the CLAUDE.md files being present and the agent picking them up. In practice this works, but the enforcement is passive rather than structural.

The coordination problem both leave open

Superpowers tells each agent how to think. Agent Teams tells agents how to talk to each other. Neither addresses the question of what phase of the work each agent should be doing at a given moment, and what gates one phase from the next.

Consider a three-agent Agent Team with Superpowers: agent A is in the implementation phase of a new auth flow; agent B is simultaneously planning a change to the user model that the auth flow will depend on; agent C is running a spec for a third feature that calls both. Each agent, individually, is following the Superpowers methodology. But the agents are in incompatible phases on interdependent work. When A finishes implementation and B finishes planning, A's implementation is against a user model that is about to change.

This is not a failure of methodology (Superpowers was followed) or of communication (Agent Teams provided the messaging channel). It is a lifecycle ordering problem: implementation started before the shared design was settled. Superpowers does not know what other agents are doing. Agent Teams knows agents are running but has no opinion on what lifecycle stage each should be in.

See which agentic coding patterns actually scale for a broader look at where parallel agentic development breaks down as task count grows, and keeping context consistent across parallel AI agents for patterns that hold up when shared decisions need to propagate across sessions.

defract approaches the same parallel-agent problem from the lifecycle side: a structured pipeline (story, design, architecture, implementation, review, release) where each agent knows its current stage and cannot advance without the prior stage completing. It works on top of Claude Code, so the choice between Superpowers and Agent Teams remains available within the defract pipeline. The Superpowers vs Agent Teams comparison is worth running against your current workflow; both are tools worth understanding. If what you're hitting is the ordering problem above, where parallel agents diverge because the design was not settled before implementation fanned out, that is the surface defract is built for.