RC’s blog

Claude Code Just Got Confusing: Plan Mode vs Superpowers vs Agent Teams — A Practical Guide

Claude Opus 4.6 dropped yesterday. Agent Teams is in research preview. The Superpowers plugin now offers subagent-driven execution. Plan Mode still exists. And somewhere in the middle of all this, you're staring at a Claude Code session wondering: which of these overlapping features do I actually use, and when?

I spent the last couple of days trying to sort this out. Here's what I found.

The Problem: Four Things That Sound Like the Same Thing

There are now at least four different "planning and execution" mechanisms available in Claude Code, and their names and capabilities blur together:

They do different things. But the terminology overlap makes it genuinely hard to tell what's what.

What Each One Actually Does

Plan Mode (Built-In)

Plan Mode is native to Claude Code. Activate it with Shift+Tab twice, or with the /plan command (v2.1.0+). When active, Claude can read your entire codebase — files, dependencies, structure — but cannot modify anything. No file writes, no command execution, nothing changes until you explicitly approve.

What you get: a structured implementation plan. Claude analyzes the problem, identifies affected files, suggests approaches, and waits for your go-ahead. When you exit Plan Mode (Shift+Tab again), Claude switches to execution.

Plan Mode is fast and cheap. Since Claude isn't executing tools or writing files, it burns fewer tokens and responds quickly. It's essentially a read-only strategic advisor.

Best for: scoped tasks where you know roughly what needs to happen but want Claude to think through the approach before touching code. Architecture reviews, dependency analysis, refactoring strategies.

Reference: Claude Code docs on common workflows, Armin Ronacher's deep dive on what Plan Mode actually is under the hood.

Superpowers Brainstorm

Superpowers is a plugin by Jesse Vincent (installed via /plugin marketplace add obra/superpowers-marketplace). It adds three main slash commands: /superpowers:brainstorm, /superpowers:write-plan, and /superpowers:execute-plan. The shorthand aliases /brainstorm, /write-plan, and /execute-plan also work.

There is no native /brainstorm command in Claude Code. Any /brainstorm or /brainstorming command you see is coming from a plugin.

Brainstorm is a Socratic dialogue. Rather than jumping into implementation planning, Claude asks you clarifying questions: what are you really trying to build? What are the edge cases? What have you considered and rejected? It iterates with you until requirements are solid, then produces a validated design document.

The key difference from Plan Mode: Plan Mode asks "how should we build this?" Brainstorm asks "what should we build, and are we sure?"

Best for: vague ideas, new features where requirements aren't nailed down, projects where you haven't thought through edge cases yet.

Superpowers Write-Plan and Execute-Plan

After brainstorming, /superpowers:write-plan generates a granular implementation plan — bite-sized tasks (2–5 minutes each), exact file paths, verification steps, TDD emphasis. This is closer to what Plan Mode produces, but more opinionated about methodology.

Then /superpowers:execute-plan offers you two choices:

  1. Subagent-Driven — dispatches a fresh subagent per task within the current session. Each subagent gets its own context window, does its work, reports back. One-directional communication.
  2. Parallel Session — opens a new Claude Code session in an isolated git worktree. The original session acts as project manager while the spawned session follows the plan.

Both of these predate Agent Teams. They use Claude Code's existing subagent mechanism and git worktree isolation — not the new multi-agent coordination system.

Reference: Superpowers SKILL.md for writing-plans, Jesse Vincent's October 2025 walkthrough.

Agent Teams (New with Opus 4.6)

Agent Teams is a research preview feature that shipped with Opus 4.6 on February 5, 2026. Enable it with the environment variable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 or via settings.json → {"experimental": {"agentTeams": true}}.

Agent Teams are fundamentally different from subagents. Subagents work within a single session and report results back to a parent — communication is one-directional. Agent Teams are multiple independent Claude Code sessions that can communicate with each other. They share a task list with dependency tracking, can claim tasks, and coordinate autonomously.

Anthropic's blog post describes it: "Instead of one agent working through tasks sequentially, you can split the work across multiple agents — each owning its piece and coordinating directly with the others." They stress-tested it by having 16 agents build a C compiler from scratch.

The catch: each agent instance is billed separately. Agent Teams incur higher token costs because every session runs its own context window.

Best for: large-scale tasks that decompose into truly independent subtasks — codebase audits, multi-module refactors, building entire subsystems from scratch. Less suited for tasks where agents would constantly conflict on the same files.

The >200K Token Pricing Question

Opus 4.6 introduces a 1M token context window (beta), a first for Opus-class models. Standard pricing is $5/$25 per million input/output tokens — unchanged from Opus 4.5.

The premium threshold: requests exceeding 200K input tokens get charged at $10/$37.50 per million tokens. Per Anthropic's pricing docs, once you cross 200K input tokens, all tokens in that request get the premium rate — not just the ones above 200K.

For subscription users (Pro, Max, Team, Enterprise): you're not directly billed per-token. Your usage is measured against a rolling token budget, and Opus tokens consume that budget faster than Sonnet tokens. The premium long-context pricing primarily affects direct API users. Subscription users feel the impact indirectly — very long sessions eat through the rolling budget faster. The "extra usage" add-on (which bills at API rates when your included budget runs out) would hit premium rates for >200K input token requests.

Context compaction — also new with Opus 4.6 — helps here. It automatically summarizes older conversation turns before you hit the ceiling, keeping effective input token count lower. Think of it as git squash for conversation history.

How to Decide What to Use

Here's the practical decision framework I've settled on:

Starting a New Feature — Requirements Unclear

Use /superpowers:brainstorm. Let the Socratic dialogue surface edge cases and nail down what you're actually building. Skip Plan Mode entirely for this phase — brainstorm already prevents code execution, and it's optimized for requirement discovery rather than implementation planning.

Requirements Clear — Need an Implementation Strategy

Two paths:

Using both in sequence is redundant. Pick one.

Ready to Execute a Plan

Quick Fix or Bug

Just ask Claude. No ceremony needed.

The Power-User Combo

  1. Brainstorm → nail requirements
  2. Write-Plan → generate implementation plan
  3. Execute → choose your path based on scope:
    • Subagent-driven for manageable scope
    • Parallel session for larger isolated work
    • Agent Teams for truly parallel, multi-module work

Model Selection Across Phases

Superpowers' workflow naturally fits this hybrid approach: burn Opus tokens during the thinking phases, drop to Sonnet for execution when you're following a well-defined plan.

Session Length Strategy

The One Sentence Summary

Brainstorm figures out what to build, Plan Mode figures out how to build it, Superpowers orchestrates the full lifecycle from idea to PR, and Agent Teams let you throw multiple Claudes at the problem in parallel.

Use one, some, or all — depending on how well you understand the problem before you start typing.