playbooks

home / skills / shotaiuchi / dotclaude / team-feature

team-feature skill

/dotclaude/skills/team-feature

This skill automatically forms and launches specialized agents to implement new features in parallel, coordinating integration and delivering a completion

npx playbooks add skill shotaiuchi/dotclaude --skill team-feature

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
4.9 KB
---
name: team-feature
description: Agent Teamsで新機能の並列実装チームを自動構成・起動
argument-hint: "[--issue N | --pr N | path | description]"
user-invocable: true
disable-model-invocation: true
---

# Feature Team

Create an Agent Team with automatically selected specialists to implement new features through parallel workstreams.

## Instructions

1. **Analyze the feature** (description, issue, or spec) to determine scope and components
2. **Select appropriate specialists** based on the selection matrix below
3. **Create the agent team** with only the selected specialists
4. Have them coordinate on integration points and produce a completion report

## Step 0: Scope Detection

Parse `$ARGUMENTS` to determine the analysis target.
See `references/agent-team/scope-detection.md` for full detection rules.

| Flag | Scope | Action |
|------|-------|--------|
| `--pr <N>` | PR | `gh pr diff <N>` + `gh pr view <N> --json title,body,files` |
| `--issue <N>` | Issue | `gh issue view <N> --json title,body,comments` |
| `--commit <ref>` | Commit | `git show <ref>` or `git diff <range>` |
| `--diff` | Unstaged changes | `git diff` |
| `--staged` | Staged changes | `git diff --staged` |
| `--branch <name>` | Branch diff | `git diff main...<name>` |
| Path pattern | File/Directory | `Glob` + `Read` |
| Free text | Description | Use as context for analysis |
| (empty or ambiguous) | Unknown | Ask user to specify target |

## Step 1: Feature Analysis

Before spawning any teammates, analyze the target to determine the feature type:

| Signal | Type |
|--------|------|
| UI components, screens, layouts, user interactions, styling | UI Feature |
| Endpoints, handlers, request/response schemas, middleware | API Feature |
| Schemas, migrations, queries, storage, ETL, indexing | Data Feature |
| Third-party APIs, webhooks, OAuth, external services | Integration |
| CI/CD, deployment, monitoring, scaling, configuration | Infrastructure |
| Mixed signals | Analyze dominant patterns and apply multiple types |

## Step 2: Specialist Selection Matrix

| Specialist | UI Feature | API Feature | Data Feature | Integration | Infrastructure |
|:-----------|:----------:|:-----------:|:------------:|:-----------:|:--------------:|
| API Designer | If needs API | Always | Always | Always | Skip |
| UI Implementer | Always | Skip | If has UI | If has UI | Skip |
| Data Modeler | If data-driven | Always | Always | Always | If storage-related |
| Business Logic | Always | Always | Always | Always | Skip |
| Test Writer | Always | Always | Always | Always | Always |
| Doc Writer | Always | Always | Always | Always | Always |
| Security Analyst | If auth-related | Always | If PII | Always | Always |

### Selection Rules

- **Always**: Spawn this specialist unconditionally
- **Skip**: Do not spawn this specialist
- **Conditional**: Spawn only if the condition is met based on feature analysis

When uncertain, **include the specialist** (prefer thoroughness over efficiency).

## Step 3: Team Creation

Spawn only the selected specialists using the **Task tool** (`subagent_type: "general-purpose"`).

**Execution Rules:**
- Send ALL Task tool calls in a **single message** for parallel execution
- Each subagent runs in its own context and returns findings to the lead (main context)
- Provide each subagent with the full target context (feature spec, file contents, etc.) in the prompt
- The lead (main context) is responsible for synthesis — do NOT spawn a subagent for synthesis

1. **API Designer**: Design API endpoints, request/response schemas, error handling, versioning, and integration contracts.

2. **UI Implementer**: Implement user interface components, layouts, interactions, accessibility, and responsive design.

3. **Data Modeler**: Design data schemas, migrations, relationships, indexes, and data access patterns.

4. **Business Logic Implementer**: Implement core business rules, validation logic, workflows, and domain-specific algorithms.

5. **Test Writer**: Create unit tests, integration tests, and edge case tests for all new functionality.

6. **Doc Writer**: Create or update API documentation, user guides, and inline code documentation.

7. **Security Analyst**: Review for authentication, authorization, input validation, data protection, and security best practices.

## Workflow

1. Lead analyzes the feature and decomposes it into parallel workstreams
2. Each selected specialist works on their designated component
3. Specialists coordinate on integration points and shared interfaces
4. Lead orchestrates integration and produces a completion report with:
   - Completed components and their status
   - Integration verification results
   - Remaining tasks or follow-up items

## Output

The lead produces a final implementation summary including:
- Feature type detected and specialists selected (with reasoning)
- Completed components with integration status
- Test coverage summary
- Remaining tasks or known limitations

Overview

This skill automatically composes and launches an Agent Team to implement new features through parallel workstreams. It analyzes a feature target (PR, issue, commit, diff, path, or free-text spec), selects appropriate specialists using a clear matrix, spawns only those specialists in parallel, and returns a synthesized completion report.

How this skill works

The skill first detects the feature scope from provided arguments and identifies the feature type (UI, API, Data, Integration, Infrastructure or mixed). It applies a specialist selection matrix and conditional rules to choose which subagents to spawn. All Task tool calls are sent in a single message so specialists run in parallel; the lead receives their outputs, coordinates integration, and produces a final implementation summary.

When to use it

  • When you need parallel implementation of a new feature across multiple disciplines
  • When a PR, issue, commit, or diff describes a feature that touches UI, API, data, or infra
  • When you want automated specialist selection to optimize team composition
  • When you need a synthesized integration report and remaining tasks
  • When you prefer thoroughness over minimal staffing for ambiguous scopes

Best practices

  • Provide a clear target: PR number, issue number, commit ref, branch, diff, or detailed description
  • Include related files or specs in the context to improve specialist outputs
  • Prefer explicit flags (e.g., --pr, --issue, --branch) to avoid ambiguity
  • Keep the lead responsible for synthesis; do not spawn a synthesis subagent
  • When uncertain about scope, allow the skill to include extra specialists rather than skip

Example use cases

  • A feature request adds a new UI screen and backend endpoint—automatically spawn UI Implementer, API Designer, Business Logic, Test Writer, Doc Writer, and others as needed
  • A data migration task detected from a commit triggers Data Modeler, Business Logic, Test Writer, Doc Writer, and Security Analyst if PII is involved
  • A third-party integration spec spawns Integration-focused specialists including API Designer, Data Modeler, Business Logic, Test Writer, Doc Writer, and Security Analyst

FAQ

How do I specify the feature to analyze?

Pass arguments like --pr <N>, --issue <N>, --commit <ref>, --branch <name>, --diff, --staged, a path pattern, or free-text description.

Can I override specialist selection?

The selection follows the matrix and conditional rules. If you want a custom team, include explicit context or request additional specialists in the input.