/team-feature

description: "Develop features in parallel with multiple agents using file ownership boundaries and dependency management"
argument-hint: "<feature-description> [--team-size N] [--branch feature/name] [--plan-first]"

Team Feature

Orchestrate parallel feature development with multiple implementer agents. Decomposes features into work streams with strict file ownership, manages dependencies, and verifies integration.

Pre-flight Checks

1. Verify `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is set 2. Parse `$ARGUMENTS`:

• `<feature-description>`: description of the feature to build
• `--team-size N`: number of implementers (default: 2)
• `--branch`: git branch name (default: auto-generated from feature description)
• `--plan-first`: decompose and get user approval before spawning

Phase 1: Analysis

1. Analyze the feature description to understand scope 2. Explore the codebase to identify:

• Files that will need modification
• Existing patterns and conventions to follow
• Integration points with existing code
• Test files that need updates

Phase 2: Decomposition

1. Decompose the feature into work streams:

• Each stream gets exclusive file ownership (no overlapping files)
• Define interface contracts between streams
• Identify dependencies between streams (blockedBy/blocks)
• Balance workload across streams

2. If `--plan-first` is set:

• Present the decomposition to the user:

     ## Feature Decomposition: {feature}

     ### Stream 1: {name}
     Owner: implementer-1
     Files: {list}
     Dependencies: none

     ### Stream 2: {name}
     Owner: implementer-2
     Files: {list}
     Dependencies: blocked by Stream 1 (needs interface from {file})

     ### Integration Contract
     {shared types/interfaces}

• Wait for user approval before proceeding
• If user requests changes, adjust decomposition

Phase 3: Team Spawn

1. If `--branch` specified, use Bash to create and checkout the branch:

   git checkout -b {branch-name}

2. Use `TeamCreate` tool to create the team with `team_name: "feature-{timestamp}"` and `description` 3. Spawn a `team-lead` agent to coordinate 4. For each work stream, use `Agent` tool to spawn a `team-implementer`:

• `name`: `implementer-{n}`
• `subagent_type`: "agent-teams:team-implementer"
• `prompt`: Include owned files, interface contracts, and implementation requirements

Phase 4: Task Creation

1. Use `TaskCreate` for each work stream:

• Subject: "{stream name}"
• Description: Owned files, requirements, interface contracts, acceptance criteria

2. Use `TaskUpdate` to set `blockedBy` relationships for dependent streams 3. Assign tasks to implementers with `TaskUpdate` (set `owner`)

Phase 5: Monitor and Coordinate

1. Monitor `TaskList` for progress 2. As implementers complete tasks:

• Check for integration issues
• Unblock dependent tasks
• Rebalance if needed

3. Handle integration point coordination:

• When an implementer completes an interface, notify dependent implementers

Phase 6: Integration Verification

After all tasks complete:

1. Use Bash to verify the code compiles/builds: run appropriate build command 2. Use Bash to run tests: run appropriate test command 3. If issues found, create fix tasks and assign to appropriate implementers 4. Report integration status to user

Phase 7: Cleanup

1. Present feature summary:

   ## Feature Complete: {feature}

   Files modified: {count}
   Streams completed: {count}/{total}
   Tests: {pass/fail}

   Changes are on branch: {branch-name}

2. Send `shutdown_request` to all teammates 3. Call `TeamDelete` to remove team resources