Stats
Actions
Tags
From team-orchestration
Creates detailed engineering implementation plans with team orchestration for multi-step projects requiring task dependencies and parallel execution. Uses specialized agents for Django, Python, FastAPI, React, and Playwright.
How this skill is triggered — by the user, by Claude, or both
Slash command
/team-orchestration:plan-with-teamThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Create a detailed implementation plan based on the user's requirements provided through the `USER_PROMPT` variable. Analyze the request, think through the implementation approach, and save a comprehensive specification document to `PLAN_OUTPUT_DIRECTORY/<name-of-plan>.md` that can be used as a blueprint for actual development work. Follow the `Instructions` and work through the `Workflow` to cr...
Create a detailed implementation plan based on the user's requirements provided through the USER_PROMPT variable. Analyze the request, think through the implementation approach, and save a comprehensive specification document to PLAN_OUTPUT_DIRECTORY/<name-of-plan>.md that can be used as a blueprint for actual development work. Follow the Instructions and work through the Workflow to create the plan.
USER_PROMPT: $1
ORCHESTRATION_PROMPT: $2 - (Optional) Guidance for team assembly, task structure, and execution strategy
PLAN_OUTPUT_DIRECTORY: specs/
TEAM_MEMBERS: .claude/agents/team/*.md
GENERAL_PURPOSE_AGENT: general-purpose
Use these specialized agents for specific task types instead of defaulting to general-purpose:
IMPORTANT: Only use general-purpose if no specialized agent matches the task type.
PLAN_OUTPUT_DIRECTORY.USER_PROMPT is provided, stop and ask the user to provide it.ORCHESTRATION_PROMPT is provided, use it to guide team composition, task granularity, dependency structure, and parallel/sequential decisions.PLAN_OUTPUT_DIRECTORY/<descriptive-name>.mdTeam Orchestration section for more details.general-purpose if no specialized agent exists for the task type.As the team lead, you have access to powerful tools for coordinating work across multiple agents. You NEVER write code directly - you orchestrate team members using these tools.
TaskCreate - Create tasks in the shared task list:
TaskCreate({
subject: "Implement user authentication",
description: "Create login/logout endpoints with JWT tokens. See specs/auth-plan.md for details.",
activeForm: "Implementing authentication" // Shows in UI spinner when in_progress
})
// Returns: taskId (e.g., "1")
TaskUpdate - Update task status, assignment, or dependencies:
TaskUpdate({
taskId: "1",
status: "in_progress", // pending → in_progress → completed
owner: "builder-auth" // Assign to specific team member
})
TaskList - View all tasks and their status:
TaskList({})
// Returns: Array of tasks with id, subject, status, owner, blockedBy
TaskGet - Get full details of a specific task:
TaskGet({ taskId: "1" })
// Returns: Full task including description
Use addBlockedBy to create sequential dependencies - blocked tasks cannot start until dependencies complete:
// Task 2 depends on Task 1
TaskUpdate({
taskId: "2",
addBlockedBy: ["1"] // Task 2 blocked until Task 1 completes
})
// Task 3 depends on both Task 1 and Task 2
TaskUpdate({
taskId: "3",
addBlockedBy: ["1", "2"]
})
Dependency chain example:
Task 1: Setup foundation → no dependencies
Task 2: Implement feature → blockedBy: ["1"]
Task 3: Write tests → blockedBy: ["2"]
Task 4: Final validation → blockedBy: ["1", "2", "3"]
Assign tasks to specific team members for clear accountability:
// Assign task to a specific builder
TaskUpdate({
taskId: "1",
owner: "builder-api"
})
// Team members check for their assignments
TaskList({}) // Filter by owner to find assigned work
Task - Deploy an agent to do work:
Task({
description: "Implement auth endpoints",
prompt: "Implement the authentication endpoints as specified in Task 1...",
subagent_type: "general-purpose",
model: "opus", // or "opus" for complex work, "haiku" for VERY simple
run_in_background: false // true for parallel execution
})
// Returns: agentId (e.g., "a1b2c3")
Store the agentId to continue an agent's work with preserved context:
// First deployment - agent works on initial task
Task({
description: "Build user service",
prompt: "Create the user service with CRUD operations...",
subagent_type: "general-purpose"
})
// Returns: agentId: "abc123"
// Later - resume SAME agent with full context preserved
Task({
description: "Continue user service",
prompt: "Now add input validation to the endpoints you created...",
subagent_type: "general-purpose",
resume: "abc123" // Continues with previous context
})
When to resume vs start fresh:
Run multiple agents simultaneously with run_in_background: true:
// Launch multiple agents in parallel
Task({
description: "Build API endpoints",
prompt: "...",
subagent_type: "general-purpose",
run_in_background: true
})
// Returns immediately with agentId and output_file path
Task({
description: "Build frontend components",
prompt: "...",
subagent_type: "general-purpose",
run_in_background: true
})
// Both agents now working simultaneously
// Check on progress
TaskOutput({
task_id: "agentId",
block: false, // non-blocking check
timeout: 5000
})
// Wait for completion
TaskOutput({
task_id: "agentId",
block: true, // blocks until done
timeout: 300000
})
TaskCreate for each step in the planTaskUpdate + addBlockedByTaskUpdate + ownerTask to execute assigned workTaskList and TaskOutputTask + resume for follow-up workTaskUpdate + status: "completed"IMPORTANT: PLANNING ONLY - Do not execute, build, or deploy. Output is a plan document.
contracts/types.py - Shared data structures, enums, type aliases for cross-agent consistencycontracts/api-schema.yaml - OpenAPI specification for API endpoints and request/response schemasfile.py::function_name, file.py::ClassName.method)team-orchestration:django-builder or python-experts:django-expertpython-experts:python-testing-expert or frontend-experts:playwright-testing-expertpython-experts:fastapi-expert or python-experts:django-expertfrontend-experts:react-typescript-expertdevops-data:devops-expertteam-orchestration:django-validator (for Django) or appropriate validatorgit-workflow:commit-expertgeneral-purpose if no specialized agent matchesORCHESTRATION_PROMPT (if provided) to guide team composition. Select specialized agents from step 7 and document in plan.ORCHESTRATION_PROMPT (if provided) to guide task granularity and parallel/sequential structure. Write out tasks with IDs, dependencies, assignments to specialized agents. Document in plan.subgraph to visually group tasks by wave number-->) connecting dependent tasksPLAN_OUTPUT_DIRECTORY/<filename>.mdReport section to write the plan to PLAN_OUTPUT_DIRECTORY/<filename>.md and provide a summary of key components# Plan: <task name>
## Task Description
<describe the task in detail based on the prompt>
## Objective
<clearly state what will be accomplished when this plan is complete>
<if task_type is feature or complexity is medium/complex, include these sections:>
## Problem Statement
<clearly define the specific problem or opportunity this task addresses>
## Solution Approach
<describe the proposed solution approach and how it addresses the objective>
</if>
## Relevant Files
Use these files to complete the task:
<list files relevant to the task with bullet points explaining why. Include new files to be created under an h3 'New Files' section if needed>
<if task involves multi-agent coordination or API boundaries, include this section:>
## Contracts
When multiple agents work in parallel or integrate across API boundaries, shared contracts ensure consistency.
### Shared Types (contracts/types.py)
```python
from dataclasses import dataclass
from typing import Optional
from datetime import datetime
from enum import Enum
class <EntityName>Status(str, Enum):
<STATUS_1> = "status_1"
<STATUS_2> = "status_2"
@dataclass
class <EntityName>:
id: int
name: str
status: <EntityName>Status
created_at: datetime
@dataclass
class <EntityName>CreateRequest:
name: str
<additional fields>
openapi: 3.0.0
info:
title: <API Name>
version: 1.0.0
components:
schemas:
<EntityName>:
type: object
required: [id, name]
properties:
id: {type: integer}
name: {type: string}
status: {type: string, enum: [status_1, status_2]}
paths:
/<resource>:
get:
summary: List <resources>
responses:
'200':
description: <Resource> list
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/<EntityName>'
post:
summary: Create <resource>
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/<EntityName>CreateRequest'
responses:
'201':
description: Created
<if complexity is medium/complex, include this section:>
<describe integration, testing, and final touches>
Task and Task* tools to deploy team members to to the building, validating, testing, deploying, and other tasks.
Select specialized agents based on task requirements. Prefer specialized agents over general-purpose.
Example for Django Project:
Agent Selection Guidelines:
true for sequential work requiring context, false for independent tasksTrack which tasks create or modify which files to prevent merge conflicts in parallel execution.
| File | CREATE | MODIFY Scope | Task ID | Wave |
|---|---|---|---|---|
<path/to/file.py> | <task-id or -> | <:: scoped function/class or -> | ||
<path/to/file.py>::<function_name> | - |
Ownership Rules:
TaskCreate call.TaskCreate to create the initial task list that all team members can see and execute.<list step by step tasks as h3 headers. Start with foundational work, then core implementation, then validation.>
CRITICAL: Select specialized agents from "Available Specialized Agents" section based on task type. Only use general-purpose if no specialized agent matches.
Visualize task dependencies and wave execution order with Mermaid.
flowchart TB
subgraph W1[Wave 1 - Parallel]
t001[<task-001-name><br/><agent-type>]
t002[<task-002-name><br/><agent-type>]
end
subgraph W2[Wave 2 - Parallel]
t003[<task-003-name><br/><agent-type>]
t004[<task-004-name><br/><agent-type>]
end
subgraph W3[Wave 3 - Sequential]
t005[<task-005-validation><br/><agent-type>]
end
t001 --> t003
t002 --> t003
t002 --> t004
t003 --> t005
t004 --> t005
<if complexity is medium/complex, include timeline visualization:>
gantt
title Task Execution Timeline
dateFormat YYYY-MM-DD
section Wave 1
<task-001-name> :t001, 2025-01-01, <duration>h
<task-002-name> :t002, 2025-01-01, <duration>h
section Wave 2
<task-003-name> :t003, after t001, <duration>h
<task-004-name> :t004, after t002, <duration>h
section Wave 3
<task-005-validation> :crit, t005, after t003, <duration>h
<list specific, measurable criteria that must be met for the task to be considered complete>
Execute these commands to validate the task is complete:
- Example: `uv run python -m py_compile apps/*.py` - Test to ensure the code compilesBefore executing this plan, validate the orchestration structure to prevent merge conflicts and ensure efficient parallel execution.
<optional additional context, considerations, or dependencies. If new libraries are needed, specify using uv add>
## Report
After creating and saving the implementation plan, provide a concise report with the following format:
✅ Implementation Plan Created
File: PLAN_OUTPUT_DIRECTORY/.md Topic: Key Components:
Contracts:
Wave Structure:
File Ownership:
Team Composition:
Team Task List:
Agent Selection Quality: ✅ All tasks assigned to specialized agents appropriate for their technology stack OR ⚠️ tasks using general-purpose (explain why specialized agents weren't suitable)
Next Steps - Plan Execution
This skill ONLY creates the plan document. To execute the plan:
Option 1: Manual Execution with Task Tool
Option 2: Use Parallel Execution Skill (if available)
/parallel-run specs/<filename>.md
Option 3: Execute Step by Step
npx claudepluginhub jpoutrin/product-forge --plugin team-orchestrationAnalyzes project work, builds mental models, decomposes into stacked task graphs with backends and difficulty ratings, and gets approval before execution. For multi-task projects needing planning.
Creates iterative development plans for Replit Agent, breaking projects into phases with tasks, checkpoints, prompts, verification steps, and rollback strategies.
Creates detailed implementation plans through interactive, iterative collaboration. Use when planning features, refactoring, or tasks with research and multi-agent analysis.