feat: Leverage Claude Code agent teams for parallel plan execution#470
feat: Leverage Claude Code agent teams for parallel plan execution#470marciogranzotto wants to merge 5 commits intoobra:mainfrom
Conversation
Documents the proposal to leverage Claude Code agent teams (TeamCreate, SendMessage, shared TaskList) in the execution skills, with detection, user choice, and cross-platform fallback. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
7-task plan covering: writing-plans handoff update, subagent-driven-development team mode (decision tree + process flow), dispatching-parallel-agents team mode, executing-plans within-batch parallelism, red flags, and integration review. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Add team mode as an optional execution path for all three execution skills, gated behind TeamCreate detection and user choice: - writing-plans: Third execution handoff option (team-based) - subagent-driven-development: Full team mode with parallel implementers, sequential review gates, team lifecycle management - dispatching-parallel-agents: Team mode alternative with inter-agent messaging and shared task tracking - executing-plans: Within-batch parallelism via teams All changes are additive and cross-platform safe - team features only activate on Claude Code with teams enabled, existing behavior is preserved on Codex, OpenCode, and Claude Code without teams. Relates to: obra#469 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
📝 WalkthroughWalkthroughAdds a team-based execution design and implementation across writing-plans, subagent-driven-development, dispatching-parallel-agents, and executing-plans, introducing TeamCreate capability detection, a user opt-in Team Mode path, team lifecycle tooling, and cross-platform fallbacks to existing sequential/subagent flows. Changes
Sequence Diagram(s)sequenceDiagram
participant User
participant Frontend as Planner
participant Runtime as "Claude Code Runtime"
participant Team as "Team Service"
participant Agents as "Team Members"
User->>Frontend: Request plan execution (choose)
Frontend->>Runtime: Check TeamCreate availability
alt TeamCreate available & user opts in
Frontend->>Runtime: TeamCreate()
Runtime->>Team: createTeam()
Team-->>Runtime: teamId
Runtime->>Agents: TaskCreate(assignments...)
Agents-->>Runtime: progress/update (TaskUpdate/SendMessage)
Runtime->>Frontend: TaskList/status updates
Agents-->>Runtime: results
Runtime->>Team: TeamDelete(teamId)
Runtime-->>Frontend: aggregated results
else Not available or user declines
Frontend->>Runtime: Execute standard sequential/subagent flow
Runtime-->>Frontend: sequential results
end
Estimated code review effort🎯 4 (Complex) | ⏱️ ~45 minutes Possibly related issues
Poem
🚥 Pre-merge checks | ✅ 4✅ Passed checks (4 passed)
✏️ Tip: You can configure your own custom pre-merge checks in the settings. ✨ Finishing touches🧪 Generate unit tests (beta)
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
There was a problem hiding this comment.
Pull request overview
Adds an optional “agent teams” execution path (Claude Code) across the plan-writing and execution skills, while preserving the existing sequential/standard behavior for non-team environments.
Changes:
- Updates execution handoff (
writing-plans) to optionally offer a Team-Based execution option whenTeamCreateis available. - Adds “Team Mode” documentation to execution skills (
subagent-driven-development,dispatching-parallel-agents,executing-plans) describing parallel coordination via teams. - Introduces design + implementation plan docs for rolling out team-based plan execution.
Reviewed changes
Copilot reviewed 6 out of 6 changed files in this pull request and generated 8 comments.
Show a summary per file
| File | Description |
|---|---|
| skills/writing-plans/SKILL.md | Adds team capability detection guidance and a Team-Based execution option in the handoff. |
| skills/subagent-driven-development/SKILL.md | Extends decision tree and documents a new Team Mode process, constraints, and lifecycle. |
| skills/dispatching-parallel-agents/SKILL.md | Adds a Team Mode section comparing standard Task dispatch vs coordinated teams. |
| skills/executing-plans/SKILL.md | Documents within-batch parallelism via teams, preserving batch checkpoints. |
| docs/plans/2026-02-13-team-based-plan-execution-design.md | Design doc describing motivation, flow, and cross-platform constraints. |
| docs/plans/2026-02-13-team-based-plan-execution-implementation.md | Detailed implementation plan and step-by-step edits for the skill docs. |
💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.
|
|
||
| **Architecture:** Each execution skill gets a "Team Mode" section that activates only when Claude Code teams are detected and the user opts in. The existing sequential subagent pattern remains the default. A shared detection-and-choice pattern is documented once and referenced by all three skills. | ||
|
|
||
| **Tech Stack:** Markdown skill files (SKILL.md), Claude Code tools (TeamCreate, SendMessage, TaskCreate/TaskUpdate/TaskList, Task) |
There was a problem hiding this comment.
This implementation plan’s “Tech Stack” and subsequent steps rely on TaskCreate/TaskUpdate/TaskList tool names. Within this repo, those names only appear in this PR, so readers can’t verify they exist. Consider either linking to the authoritative Claude Code teams tool reference or rewording to avoid asserting specific tool names unless they’re confirmed.
| **Tech Stack:** Markdown skill files (SKILL.md), Claude Code tools (TeamCreate, SendMessage, TaskCreate/TaskUpdate/TaskList, Task) | |
| **Tech Stack:** Markdown skill files (SKILL.md), Claude Code tools for team creation and messaging (e.g., TeamCreate, SendMessage) plus task management tools for creating, updating, and listing tasks (refer to the Claude Code teams tool reference for the exact tool names in your environment) |
There was a problem hiding this comment.
These are real Claude Code built-in tools provided by the runtime (TeamCreate, SendMessage, TaskCreate, TaskUpdate, TaskList). They're part of the Claude Code teams feature currently in beta. Since they're runtime-provided, they won't appear in this repo's codebase. I've updated the Tech Stack description to clarify these are Claude Code built-in tools and grouped them by function (team management vs task management).
🤖 Generated with Claude Code
| **"Plan complete and saved to `docs/plans/<filename>.md`. Execution options:** | ||
|
|
||
| **1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration | ||
|
|
||
| **2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints | ||
|
|
||
| **3. Team-Based (parallel, this session)** *(only if TeamCreate is available)* - Spawn an agent team with parallel implementers and reviewers, coordinated via shared task list | ||
|
|
||
| **Which approach?"** | ||
|
|
There was a problem hiding this comment.
The quoted/bold completion prompt is split across lines, leaving the opening quote on the previous line and only a closing quote on the next line. This renders oddly and is easy to copy incorrectly; consider either removing the quotes entirely or making the full prompt a single quoted string with balanced quotes.
There was a problem hiding this comment.
This formatting pattern is pre-existing in the original writing-plans/SKILL.md - our change only added Option 3 and updated the prompt text. Happy to clean it up as part of this PR if desired, but it's not a regression.
🤖 Generated with Claude Code
skills/executing-plans/SKILL.md
Outdated
| If `TeamCreate` is available and the user opted in during the writing-plans handoff, parallelize tasks within each batch. | ||
|
|
There was a problem hiding this comment.
This Team Mode is gated on “user opted in during the writing-plans handoff”, but writing-plans currently routes team-based execution to subagent-driven-development (not executing-plans) and doesn’t capture an opt-in for executing-plans. As written, this condition is hard/impossible to satisfy when executing-plans is run (especially if invoked directly from a plan). Consider moving detection + user choice into executing-plans itself (or explicitly adding a handoff path that opts into team mode for executing-plans).
There was a problem hiding this comment.
Good catch. Fixed - executing-plans now includes its own detection + user choice flow: "Before executing the first batch, check if the TeamCreate tool is available. If it is, ask the user whether to parallelize tasks within batches or proceed sequentially." This ensures team mode works when executing-plans is invoked directly from a plan header, without depending on the writing-plans handoff.
🤖 Generated with Claude Code
| **What changes:** | ||
| - Step 2 (Execute Batch): Instead of executing 3 tasks sequentially, spawn a team and assign batch tasks to team members working in parallel | ||
| - Step 3 (Report): Wait for all batch members to complete, then report combined results | ||
| - Steps 1, 4, 5: Unchanged (plan review, feedback loop, and completion stay the same) |
There was a problem hiding this comment.
Within-batch parallelism can cause conflicts when tasks in the same batch touch overlapping files or have implicit dependencies (the standard flow avoids this by being sequential). The Team Mode section should add a constraint/decision step to only parallelize tasks that are independent (otherwise fall back to sequential execution for that batch/task).
There was a problem hiding this comment.
Good point. Added an explicit independence constraint to the executing-plans team mode section: "Only parallelize tasks within a batch if they are independent (touch different files, no implicit dependencies). If tasks in a batch may conflict, fall back to sequential execution for that batch."
🤖 Generated with Claude Code
skills/executing-plans/SKILL.md
Outdated
| 1. `TeamCreate` for the batch (or reuse existing team) | ||
| 2. Assign batch tasks to team members | ||
| 3. Wait for all to complete | ||
| 4. Report results, wait for feedback | ||
| 5. `TeamDelete` when all work is done (or reuse for next batch) |
There was a problem hiding this comment.
The per-batch lifecycle bullets are a bit ambiguous about whether the team is created/deleted each batch or reused across batches (both are mentioned). Clarify the intended default (e.g., create once and reuse across batches, then delete at the end) so the execution flow is unambiguous.
| 1. `TeamCreate` for the batch (or reuse existing team) | |
| 2. Assign batch tasks to team members | |
| 3. Wait for all to complete | |
| 4. Report results, wait for feedback | |
| 5. `TeamDelete` when all work is done (or reuse for next batch) | |
| _Default:_ Create a single team at the first batch, reuse it across batches, then delete it after the final batch when all work is done. | |
| 1. For the first batch, call `TeamCreate` to create the team (for later batches, reuse the existing team) | |
| 2. Assign batch tasks to team members | |
| 3. Wait for all to complete | |
| 4. Report results, wait for feedback; if more batches remain, continue with the same team; after the final batch and approval, call `TeamDelete` |
There was a problem hiding this comment.
Agreed. Clarified the lifecycle - the ambiguous parentheticals have been replaced with a clear default: create the team once before the first batch, reuse it across batches, and call TeamDelete after the final batch completes.
🤖 Generated with Claude Code
| 1. **Create:** `TeamCreate` at start of execution | ||
| 2. **Staff:** Spawn implementer agents as team members via `Task` with `team_name` | ||
| 3. **Assign:** Create tasks via `TaskCreate`, assign via `TaskUpdate` with `owner` | ||
| 4. **Coordinate:** Use `SendMessage` for review feedback, fix instructions |
There was a problem hiding this comment.
This section introduces tool/interface names like TaskCreate, TaskUpdate, TaskList, and a team_name parameter, but these aren’t referenced elsewhere in the repo’s skills/docs (search shows only this PR). To avoid instructing the agent to call nonexistent/incorrect tools, please either (a) align these names with the actual Claude Code teams API, or (b) describe the actions generically and explicitly map them to the real tool calls used in this project.
There was a problem hiding this comment.
These are all real Claude Code built-in tools and parameters - TeamCreate, TaskCreate, TaskUpdate, TaskList, SendMessage, TeamDelete, and the team_name parameter on Task are part of the Claude Code teams API (currently in beta). They're provided by the Claude Code runtime, which is why they don't appear elsewhere in this repo. Added a note above the Team Lifecycle section clarifying these are Claude Code built-in tools.
🤖 Generated with Claude Code
| - **Implementers on the same task is NOT OK:** one implementer per task | ||
| - **Team lead handles review dispatch:** don't delegate review scheduling to implementers | ||
| - **Use SendMessage for fix instructions:** when a reviewer finds issues, message the implementer with specific fixes needed | ||
| - **Use shared TaskList for tracking:** all task state lives in the team's task list |
There was a problem hiding this comment.
Team mode says to use a shared TaskList as the source of truth, but the standard process above uses TodoWrite for task tracking. Please clarify in Team Mode whether TodoWrite is still maintained (and how it stays in sync) or whether tracking fully switches to the team TaskList, to avoid split-brain task state.
| - **Use shared TaskList for tracking:** all task state lives in the team's task list | |
| - **Use shared TaskList for tracking:** in team mode the team `TaskList` is the single source of truth for task state. Do not maintain a separate `TodoWrite`; if `TodoWrite` is used at all, it must only mirror the `TaskList` and be updated from it, never the other way around. |
There was a problem hiding this comment.
Good catch. Updated the text to explicitly state that in team mode, the shared TaskList replaces TodoWrite as the single source of truth for task state: "Do not maintain both simultaneously to avoid split-brain state."
🤖 Generated with Claude Code
| | Dispatch | Individual `Task` tool calls | `TeamCreate` + team members | | ||
| | Communication | None between agents | `SendMessage` for sharing findings | | ||
| | Progress tracking | Wait for Task return | Shared `TaskList` with live status | | ||
| | Result collection | Read each Task result | Agents report via messages + `TaskUpdate` | | ||
| | Best for | Quick independent investigations | Longer investigations needing coordination | |
There was a problem hiding this comment.
Team Mode references a shared TaskList and using TaskUpdate for result collection, but the rest of the skill only demonstrates plain Task(...) calls. Since TaskList/TaskUpdate aren’t used elsewhere in the repo, add a brief note defining what these refer to in Claude Code teams (or adjust to the actual tool names) so the instructions are actionable.
There was a problem hiding this comment.
TaskList, TaskUpdate, TaskCreate, and SendMessage are Claude Code built-in tools for team coordination (currently in beta). They're provided by the runtime, not defined in this project. Added a note at the top of the Team Mode section clarifying that these tools are provided by the Claude Code teams API.
🤖 Generated with Claude Code
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 2
🤖 Fix all issues with AI agents
In `@docs/plans/2026-02-13-team-based-plan-execution-implementation.md`:
- Around line 14-15: The document jumps from the top-level title directly to
"### Task 1" which breaks MD001; insert an h2 heading (e.g., "## Implementation
Tasks") between the separator and the existing "### Task 1" so the hierarchy
reads h1 → h2 → h3; update the immediate surrounding text near the "### Task 1:
Add team detection and choice pattern to `writing-plans`" heading to place the
new "## Implementation Tasks" heading above it.
In `@skills/executing-plans/SKILL.md`:
- Around line 52-74: The Team Mode section is ambiguous about whether to create
a new team per batch or reuse a single team; pick one strategy and update the
text to explicitly state it (use the symbols TeamCreate and TeamDelete). For a
per-batch strategy: state that TeamCreate is called at the start of each batch,
TeamDelete is called after that batch completes and feedback is received, and
clarify that no team persists across batches. For a reuse strategy: state that
TeamCreate is invoked once before the first batch, the same team is used for all
batches, and TeamDelete is called only after the final batch completes (include
guidance about when to reuse vs. recreate and any conditions to force recreate).
Replace the existing ambiguous lines referencing "or reuse existing team" and
"or reuse for next batch" with the chosen explicit lifecycle and brief
rationale.
🧹 Nitpick comments (3)
skills/dispatching-parallel-agents/SKILL.md (1)
82-111: Clarify detection mechanism and opt-in flow reference.The Team Mode section states "If
TeamCreateis available and the user opts in" but doesn't explain:
- How to detect
TeamCreateavailability (tool introspection? Try-catch? Environment variable?)- Where the user opt-in happens (presumably in
writing-plansper the other files, but not mentioned here)📝 Suggested clarification
Add a brief note after line 84:
If `TeamCreate` is available and the user opts in, use a coordinated team instead of individual `Task` calls. + +**Note:** Team availability is detected in `writing-plans` skill during execution handoff. If you're using this skill standalone, check for `TeamCreate` tool availability before offering team mode to the user.This cross-references the detection location and provides guidance for standalone usage.
docs/plans/2026-02-13-team-based-plan-execution-design.md (1)
11-18: Detection mechanism needs more specificity.Line 15 states "attempt
TeamCreateor check for the tool's availability" but doesn't specify which approach to use or how to implement tool availability checking. This ambiguity could lead to inconsistent implementations across the three skills.Consider adding guidance on the preferred detection approach:
1. **Detect** whether the environment supports teams (e.g., attempt `TeamCreate` or check for the tool's availability) + - Preferred: Check if `TeamCreate` tool is present in the available tools list before attempting to use it + - Fallback: Wrap `TeamCreate` in try-catch and fall back to standard mode on errorThis would ensure consistent detection patterns across all three skills that implement team mode.
skills/writing-plans/SKILL.md (1)
99-126: ClarifyTeamCreateavailability detection mechanism across execution skills.Line 101 states "check if the
TeamCreatetool is available in this environment" without specifying how. This vagueness is consistent across writing-plans, subagent-driven-development, executing-plans, and dispatching-parallel-agents. Since Superpowers is cross-platform (Claude Code, Codex, OpenCode), a documented canonical pattern would improve implementer clarity—such as: attemptTeamCreatecall, fall back gracefully on error, or reference platform-specific discovery (e.g., MCPtools/listfor Claude Code). This avoids each skill requiring its own interpretation.
- executing-plans: Add self-contained team detection instead of depending on writing-plans handoff (Copilot obra#3) - executing-plans: Add independence constraint for within-batch parallelism to prevent file conflicts (Copilot obra#4) - executing-plans: Clarify team lifecycle - create once before first batch, reuse across batches, delete after final batch (Copilot obra#5, CodeRabbit obra#10) - subagent-driven-development: Clarify TaskList replaces TodoWrite in team mode to avoid split-brain state (Copilot obra#7) - All skills: Add note that TeamCreate/TaskCreate/etc. are Claude Code built-in runtime tools (Copilot obra#1, obra#6, obra#8) - Implementation plan: Fix heading hierarchy MD001 violation (CodeRabbit obra#9) - Implementation plan: Clarify Tech Stack tool descriptions Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
There was a problem hiding this comment.
Actionable comments posted: 1
Caution
Some comments are outside the diff and can’t be posted inline due to platform limitations.
⚠️ Outside diff range comments (1)
skills/executing-plans/SKILL.md (1)
18-23:⚠️ Potential issue | 🟡 MinorClarify task tracking source of truth in Team Mode.
Step 1 instructs creating
TodoWrite, but Team Mode introduces team tooling without explicitly overriding task tracking. This can lead to split-brain state (TodoWrite vs TaskList). Consider adding an explicit note in Team Mode that TaskList replaces TodoWrite for team runs.💡 Suggested wording
### Team Mode (Claude Code Only) Before executing the first batch, check if the `TeamCreate` tool is available... +**Task tracking:** In team mode, use the team's `TaskList` as the single source of truth. Do not create or maintain `TodoWrite` in parallel.Also applies to: 52-76
🤖 Fix all issues with AI agents
In `@docs/plans/2026-02-13-team-based-plan-execution-implementation.md`:
- Around line 299-305: The Task 5 line is ambiguous about team lifecycle—update
the lifecycle text so it matches the chosen reuse-across-batches strategy:
replace "TeamDelete (or reuse for next batch)" with a clear instruction like
"Reuse team across batches; delete only after the final batch completes" and
ensure any mention of TeamCreate/TeamDelete elsewhere (e.g., the "TeamCreate"
and "TeamDelete" labels in this list) reflects the create-once,
reuse-until-final-batch policy so the plan is consistent.
docs/plans/2026-02-13-team-based-plan-execution-implementation.md
Outdated
Show resolved
Hide resolved
Update the plan doc's Task 5 to match the clarified lifecycle and detection wording already applied to skills/executing-plans/SKILL.md. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Analysis of 11 automated review comments (Copilot + CodeRabbit) with evaluations, suggested responses, and action plan. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
marciogranzotto
force-pushed
the
feat/team-based-plan-execution
branch
from
dbfce39 to
aac5ccd
Compare
There was a problem hiding this comment.
Actionable comments posted: 2
🤖 Fix all issues with AI agents
In `@docs/plans/2026-02-13-team-based-plan-execution-implementation.md`:
- Around line 31-44: The quoted prompt spanning multiple lines should be
rewritten to avoid dangling opening/closing quotes: replace the multi-line
quoted block that begins with "Plan complete and saved to
`docs/plans/<filename>.md`. Execution options:" and lists Option 1
(Subagent-Driven), Option 2 (Parallel Session), and Option 3 (Team-Based) with
either a single-line prompt or a proper blockquote block; ensure the conditional
mention of TeamCreate remains inline with Option 3 (e.g., mark Option 3 as shown
only if TeamCreate is available) and keep the Options text together so there are
no stray opening or closing quote characters across lines.
- Around line 147-173: Update the flowchart labels and sequencing so they match
the Team Lifecycle: change the node labeled "TeamCreate with implementer agents"
to "TeamCreate (empty team)" and ensure the subsequent node/edge clarifies that
implementers are spawned via Task (use the existing "Assign independent tasks to
implementers via TaskCreate" node or rename to emphasize Task-based spawning),
and adjust the arrow order so "TeamCreate (empty team)" flows to the Task-based
implementer spawn/assignment step (Task / TaskCreate with team_name) before
"Implementers work in parallel."
| After saving the plan, check for team support and offer execution choice: | ||
|
|
||
| **Detection:** Before presenting options, check if the `TeamCreate` tool is available in this environment. | ||
| If it is, include Option 3 below. If not, only show Options 1 and 2. | ||
|
|
||
| **"Plan complete and saved to `docs/plans/<filename>.md`. Execution options:** | ||
|
|
||
| **1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration | ||
|
|
||
| **2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints | ||
|
|
||
| **3. Team-Based (parallel, this session)** *(only if TeamCreate is available)* - Spawn an agent team with parallel implementers and reviewers, coordinated via shared task list | ||
|
|
||
| **Which approach?"** |
There was a problem hiding this comment.
Tighten the prompt formatting to avoid dangling quotes across lines.
The opening quote in Line 36 and closing quote in Line 44 span multiple lines, which reads awkwardly and is easy to copy incorrectly. Consider converting it to a blockquote or a single-line prompt.
📝 Possible cleanup
-**"Plan complete and saved to `docs/plans/<filename>.md`. Execution options:**
+> **Plan complete and saved to `docs/plans/<filename>.md`. Execution options:**
...
-**Which approach?"**
+> **Which approach?**🤖 Prompt for AI Agents
In `@docs/plans/2026-02-13-team-based-plan-execution-implementation.md` around
lines 31 - 44, The quoted prompt spanning multiple lines should be rewritten to
avoid dangling opening/closing quotes: replace the multi-line quoted block that
begins with "Plan complete and saved to `docs/plans/<filename>.md`. Execution
options:" and lists Option 1 (Subagent-Driven), Option 2 (Parallel Session), and
Option 3 (Team-Based) with either a single-line prompt or a proper blockquote
block; ensure the conditional mention of TeamCreate remains inline with Option 3
(e.g., mark Option 3 as shown only if TeamCreate is available) and keep the
Options text together so there are no stray opening or closing quote characters
across lines.
| "Read plan, extract tasks, identify independent groups" [shape=box]; | ||
| "TeamCreate with implementer agents" [shape=box]; | ||
| "Assign independent tasks to implementers via TaskCreate" [shape=box]; | ||
| "Implementers work in parallel" [shape=box]; | ||
| "As each implementer completes:" [shape=box]; | ||
|
|
||
| subgraph cluster_per_task { | ||
| label="Per Completed Task (sequential)"; | ||
| "Dispatch spec reviewer for task" [shape=box]; | ||
| "Spec passes?" [shape=diamond]; | ||
| "Send fix instructions to implementer" [shape=box]; | ||
| "Dispatch code quality reviewer" [shape=box]; | ||
| "Quality passes?" [shape=diamond]; | ||
| "Send quality fix instructions" [shape=box]; | ||
| "Mark task complete" [shape=box]; | ||
| } | ||
|
|
||
| "More tasks to assign?" [shape=diamond]; | ||
| "Assign next batch to idle implementers" [shape=box]; | ||
| "All tasks complete" [shape=box]; | ||
| "Shutdown team" [shape=box]; | ||
| "Final code review + finishing-a-development-branch" [shape=box]; | ||
|
|
||
| "Read plan, extract tasks, identify independent groups" -> "TeamCreate with implementer agents"; | ||
| "TeamCreate with implementer agents" -> "Assign independent tasks to implementers via TaskCreate"; | ||
| "Assign independent tasks to implementers via TaskCreate" -> "Implementers work in parallel"; | ||
| "Implementers work in parallel" -> "As each implementer completes:"; |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
cd /tmp && find . -type f -name "*team-based-plan-execution-implementation.md" 2>/dev/null | head -5Repository: obra/superpowers
Length of output: 42
🏁 Script executed:
git ls-files | grep -i "team-based-plan-execution"Repository: obra/superpowers
Length of output: 183
🏁 Script executed:
git ls-files docs/plans/ | head -20Repository: obra/superpowers
Length of output: 353
🏁 Script executed:
cat -n docs/plans/2026-02-13-team-based-plan-execution-implementation.md | sed -n '140,210p'Repository: obra/superpowers
Length of output: 4153
🏁 Script executed:
cat -n docs/plans/2026-02-13-team-based-plan-execution-implementation.md | sed -n '1,50p'Repository: obra/superpowers
Length of output: 2889
🏁 Script executed:
cat -n docs/plans/2026-02-13-team-based-plan-execution-implementation.md | sed -n '202,220p'Repository: obra/superpowers
Length of output: 818
Clarify the Team Lifecycle sequencing in the flowchart: TeamCreate creates an empty team only; implementers are spawned separately via Task.
The flowchart at line 148 labels "TeamCreate with implementer agents," but the Team Lifecycle section (lines 204–206) clarifies that TeamCreate only creates the team structure and implementers are spawned afterward via Task with team_name. Align the flowchart wording to match the actual sequencing to prevent confusion about correct tool usage:
- Line 148: Change "TeamCreate with implementer agents" to "TeamCreate (empty team)"
- Line 149: Clarify that the task assignment step follows implementer spawning via
Task
🤖 Prompt for AI Agents
In `@docs/plans/2026-02-13-team-based-plan-execution-implementation.md` around
lines 147 - 173, Update the flowchart labels and sequencing so they match the
Team Lifecycle: change the node labeled "TeamCreate with implementer agents" to
"TeamCreate (empty team)" and ensure the subsequent node/edge clarifies that
implementers are spawned via Task (use the existing "Assign independent tasks to
implementers via TaskCreate" node or rename to emphasize Task-based spawning),
and adjust the arrow order so "TeamCreate (empty team)" flows to the Task-based
implementer spawn/assignment step (Task / TaskCreate with team_name) before
"Implementers work in parallel."
|
This wording feels a bit confusing when you ask it to execute the plan using a team of agents |
2 participants
Summary
TeamCreate,SendMessage, sharedTaskList) to all three execution skills as an optional parallel execution pathRelates to: #469
Changes
skills/writing-plans/SKILL.mdTeamCreateis availableskills/subagent-driven-development/SKILL.md(highest impact)skills/dispatching-parallel-agents/SKILL.mdTaskdispatchskills/executing-plans/SKILL.mdDesign & Planning docs
docs/plans/2026-02-13-team-based-plan-execution-design.md- Approved design documentdocs/plans/2026-02-13-team-based-plan-execution-implementation.md- 7-task implementation planCross-platform safety
All team-related instructions are gated behind detection. Skills maintain two clear paths:
No skill breaks or degrades on non-Claude-Code environments.
Test plan
TeamCreateavailabilitysubagent-driven-developmentteam mode with a multi-task plandispatching-parallel-agentsteam mode with independent investigationsexecuting-plansteam mode within-batch parallelism🤖 Generated with Claude Code
Summary by CodeRabbit
Documentation
New Features