feat: Leverage Claude Code agent teams for parallel plan execution

[marciogranzotto]

Problem

The execution skills (executing-plans, subagent-driven-development, dispatching-parallel-agents) use a sequential subagent dispatch pattern: one subagent at a time, with the main agent as controller. Claude Code now offers an agent teams feature (TeamCreate, SendMessage, shared TaskList) that enables true parallel execution with persistent inter-agent coordination.

Since superpowers is cross-platform (Claude Code, Codex, OpenCode), team support should be additive: detect availability, ask the user, and fall back to the current pattern when teams aren't available.

What Teams Enable

• True parallelism: Multiple implementer agents working on independent tasks simultaneously, instead of one-at-a-time
• Persistent coordination: Team members can message each other, share findings, and coordinate through a shared task list - the controller isn't a bottleneck
• Structured lifecycle: Teams have explicit creation, task assignment, and shutdown phases that map naturally to plan execution

Suggested Approach

Detection & User Choice Flow

When an execution skill starts, before dispatching work:

1. Detect whether the environment supports teams (e.g., check for TeamCreate tool availability)
2. If available, ask the user: "Agent teams are available. Would you like to use a team for parallel execution, or proceed with the standard sequential approach?"
3. If not available (or user declines), proceed with the current subagent pattern unchanged

This keeps superpowers fully functional on Codex, OpenCode, and Claude Code installations without teams enabled.

Per-Skill Impact

subagent-driven-development (highest value):
Currently dispatches one implementer subagent at a time, waits for completion, runs two review stages, then moves to next task. With teams:

• Spawn a team with implementer agents that can work on independent tasks in parallel
• Reviewer agents can be dispatched as tasks complete, without blocking other implementers
• The controller orchestrates via the shared task list and messages rather than sequential dispatch
• Constraint: tasks with dependencies still run sequentially - only independent tasks parallelize
• Review gates remain sequential per task (spec review must pass before code quality review)

dispatching-parallel-agents (natural fit):
Already designed for parallel independent work, but currently uses individual Task tool calls without coordination. With teams:

• Agents become team members that can share findings via SendMessage
• Results are collected through the shared task list rather than waiting for individual agent returns
• Better visibility into progress while agents work

executing-plans (modest benefit):
Designed for batch execution with human review checkpoints between batches. With teams:

• Tasks within a batch could run in parallel instead of sequentially
• Review checkpoints between batches remain unchanged (human-in-the-loop)
• Benefit is smaller here since the human review gates limit parallelism

writing-plans Entry Point

Add a third execution handoff option alongside the existing two:

1. Subagent-Driven (this session) - existing
2. Parallel Session (separate) - existing
3. Team-Based (parallel, this session) - only shown when TeamCreate is detected

Proposed Phases

1. Team detection and user choice infrastructure - shared pattern usable by all three skills
2. subagent-driven-development team mode - highest value, parallel implementers with sequential review gates
3. dispatching-parallel-agents team mode - natural fit, coordinated team members with messaging
4. executing-plans team mode - modest benefit, within-batch parallelism

Cross-Platform Considerations

All team-related instructions must be gated behind detection. Skills should maintain two clear paths:

• Current subagent pattern (default, works everywhere)
• Team pattern (Claude Code with teams enabled, user opted in)

No skill should break or degrade on non-Claude-Code environments.

Implementation Plan

A detailed 7-task implementation plan is available at: https://github.com/marciogranzotto/superpowers/blob/feat/team-based-plan-execution/docs/plans/2026-02-13-team-based-plan-execution-implementation.md

It covers:

1. Add team-based option to writing-plans execution handoff
2. Update subagent-driven-development decision tree
3. Add full team mode process flow to subagent-driven-development
4. Add team mode to dispatching-parallel-agents
5. Add within-batch parallelism to executing-plans
6. Team-specific red flags and cross-platform safety notes
7. Integration review

Note

The Claude Code teams feature is currently in beta. This proposal is designed to be additive - it should be implemented only when the teams API stabilizes, and all team-mode paths should gracefully degrade when the feature isn't available.

[TyceHerrman]

this looks like a duplicate of #429