Claude-Code-Workflow/docs/skills/claude-collaboration.md

Claude Skills - Team Collaboration

One-Liner

Team Collaboration Skills is a multi-role collaborative work orchestration system — Through coordinator, worker roles, and message bus, it enables parallel processing and state synchronization for complex tasks.

Pain Points Solved

Pain Point	Current State	Claude_dms3 Solution
Single model limitation	Can only call one AI model	Multi-role parallel collaboration, leveraging各自专长
Chaotic task orchestration	Manual task dependency and state management	Automatic task discovery, dependency resolution, pipeline orchestration
Fragmented collaboration	Team members work independently	Unified message bus, shared state, progress sync
Resource waste	Repeated context loading	Wisdom accumulation, exploration cache, artifact reuse

Skills List

Skill	Function	Trigger
team-coordinate	Universal team coordinator (dynamic role generation)	/team-coordinate
team-lifecycle-v5	Full lifecycle team (spec→impl→test→review)	/team-lifecycle
team-planex	Plan-execute pipeline (plan while executing)	/team-planex
team-review	Code review team (scan→review→fix)	/team-review
team-testing	Testing team (strategy→generate→execute→analyze)	/team-testing

Skills Details

team-coordinate

One-Liner: Universal team coordinator — Dynamically generates roles and orchestrates execution based on task analysis

Trigger:

/team-coordinate <task-description>
/team-coordinate --role=coordinator <task>
/team-coordinate --role=<worker> --session=<path>

Features:

• Only coordinator is built-in, all worker roles are dynamically generated at runtime
• Supports inner-loop roles (handle multiple same-prefix tasks)
• Fast-Advance mechanism skips coordinator to directly spawn successor tasks
• Wisdom accumulates cross-task knowledge

Role Registry:

Role	File	Task Prefix	Type
coordinator	roles/coordinator/role.md	(none)	orchestrator
(dynamic)	<session>/roles/<role>.md	(dynamic)	worker

Pipeline:

Task Analysis → Generate Roles → Initialize Session → Create Task Chain → Spawn First Batch Workers → Loop Progress → Completion Report

Session Directory:

.workflow/.team/TC-<slug>-<date>/
├── team-session.json           # Session state + dynamic role registry
├── task-analysis.json          # Phase 1 output
├── roles/                      # Dynamic role definitions
├── artifacts/                  # All MD deliverables
├── wisdom/                     # Cross-task knowledge
├── explorations/               # Shared exploration cache
├── discussions/                # Inline discussion records
└── .msg/                       # Team message bus logs

---

team-lifecycle-v5

One-Liner: Full lifecycle team — Complete pipeline from specification to implementation to testing to review

Trigger:

/team-lifecycle <task-description>

Features:

• Based on team-worker agent architecture, all workers share the same agent definition
• Role-specific Phase 2-4 loaded from markdown specs
• Supports specification pipeline, implementation pipeline, frontend pipeline

Role Registry:

Role	Spec	Task Prefix	Inner Loop
coordinator	roles/coordinator/role.md	(none)	-
analyst	role-specs/analyst.md	RESEARCH-*	false
writer	role-specs/writer.md	DRAFT-*	true
planner	role-specs/planner.md	PLAN-*	true
executor	role-specs/executor.md	IMPL-*	true
tester	role-specs/tester.md	TEST-*	false
reviewer	role-specs/reviewer.md	REVIEW-*	false
architect	role-specs/architect.md	ARCH-*	false
fe-developer	role-specs/fe-developer.md	DEV-FE-*	false
fe-qa	role-specs/fe-qa.md	QA-FE-*	false

Pipeline Definitions:

Specification Pipeline (6 tasks):
  RESEARCH-001 → DRAFT-001 → DRAFT-002 → DRAFT-003 → DRAFT-004 → QUALITY-001

Implementation Pipeline (4 tasks):
  PLAN-001 → IMPL-001 → TEST-001 + REVIEW-001

Full Lifecycle (10 tasks):
  [Spec Pipeline] → PLAN-001 → IMPL-001 → TEST-001 + REVIEW-001

Frontend Pipeline:
  PLAN-001 → DEV-FE-001 → QA-FE-001 (GC loop, max 2 rounds)

Quality Gate (after QUALITY-001 completion):

═════════════════════════════════════════
SPEC PHASE COMPLETE
Quality Gate: <PASS|REVIEW|FAIL> (<score>%)

Dimension Scores:
  Completeness:  <bar> <n>%
  Consistency:   <bar> <n>%
  Traceability:  <bar> <n>%
  Depth:         <bar> <n>%
  Coverage:      <bar> <n>%

Available Actions:
  resume              -> Proceed to implementation
  improve             -> Auto-improve weakest dimension
  improve <dimension> -> Improve specific dimension
  revise <TASK-ID>    -> Revise specific document
  recheck             -> Re-run quality check
  feedback <text>     -> Inject feedback, create revision
═════════════════════════════════════════

User Commands (wake paused coordinator):

Command	Action
check / status	Output execution status graph, no progress
resume / continue	Check worker status, advance next step
revise <TASK-ID> [feedback]	Create revision task + cascade downstream
feedback <text>	Analyze feedback impact, create targeted revision chain
recheck	Re-run QUALITY-001 quality check
improve [dimension]	Auto-improve weakest dimension in readiness-report

---

team-planex

One-Liner: Plan-and-execute team — Planner and executor work in parallel through per-issue beat pipeline

Trigger:

/team-planex <task-description>
/team-planex --role=planner <input>
/team-planex --role=executor --input <solution-file>

Features:

• 2-member team (planner + executor), planner serves as lead role
• Per-issue beat: planner creates EXEC-* task immediately after completing each issue's solution
• Solution written to intermediate artifact file, executor loads from file
• Supports multiple execution backends (agent/codex/gemini)

Role Registry:

Role	File	Task Prefix	Type
planner	roles/planner.md	PLAN-*	pipeline (lead)
executor	roles/executor.md	EXEC-*	pipeline

Input Types:

Input Type	Format	Example
Issue IDs	Direct ID input	--role=planner ISS-20260215-001 ISS-20260215-002
Requirement text	--text '...'	--role=planner --text 'Implement user authentication module'
Plan file	--plan path	--role=planner --plan plan/2026-02-15-auth.md

Wave Pipeline (per-issue beat):

Issue 1:  planner plans solution → write artifact → conflict check → create EXEC-* → issue_ready
                ↓ (executor starts immediately)
Issue 2:  planner plans solution → write artifact → conflict check → create EXEC-* → issue_ready
                ↓ (executor consumes in parallel)
Issue N:  ...
Final:    planner sends all_planned → executor completes remaining EXEC-* → finish

Execution Method Selection:

Executor	Backend	Use Case
agent	code-developer subagent	Simple tasks, synchronous execution
codex	ccw cli --tool codex --mode write	Complex tasks, background execution
gemini	ccw cli --tool gemini --mode write	Analysis tasks, background execution

User Commands:

Command	Action
check / status	Output execution status graph, no progress
resume / continue	Check worker status, advance next step
add <issue-ids or --text '...' or --plan path>	Append new tasks to planner queue

---

team-review

One-Liner: Code review team — Unified code scanning, vulnerability review, optimization suggestions, and auto-fix

Trigger:

/team-review <target-path>
/team-review --full <target-path>      # scan + review + fix
/team-review --fix <review-files>      # fix only
/team-review -q <target-path>          # quick scan only

Features:

• 4-role team (coordinator, scanner, reviewer, fixer)
• Multi-dimensional review: security, correctness, performance, maintainability
• Auto-fix loop (review → fix → verify)

Role Registry:

Role	File	Task Prefix	Type
coordinator	roles/coordinator/role.md	RC-*	orchestrator
scanner	roles/scanner/role.md	SCAN-*	read-only analysis
reviewer	roles/reviewer/role.md	REV-*	read-only analysis
fixer	roles/fixer/role.md	FIX-*	code generation

Pipeline (CP-1 Linear):

coordinator dispatch
  → SCAN-* (scanner: toolchain + LLM scan)
  → REV-*  (reviewer: deep analysis + report)
  → [User confirmation]
  → FIX-*  (fixer: plan + execute + verify)

Checkpoints:

Trigger	Location	Behavior
Review→Fix transition	REV-* complete	Pause, show review report, wait for user resume to confirm fix
Quick mode (-q)	After SCAN-*	Pipeline ends after scan, no review/fix
Fix-only mode (--fix)	Entry	Skip scan/review, go directly to fixer

Review Dimensions:

Dimension	Check Points
Security (sec)	Injection vulnerabilities, sensitive data leakage, permission control
Correctness (cor)	Boundary conditions, error handling, type safety
Performance (perf)	Algorithm complexity, I/O optimization, resource usage
Maintainability (maint)	Code structure, naming conventions, comment quality

---

team-testing

One-Liner: Testing team — Progressive test coverage through Generator-Critic loop

Trigger:

/team-testing <task-description>

Features:

• 5-role team (coordinator, strategist, generator, executor, analyst)
• Three pipelines: Targeted, Standard, Comprehensive
• Generator-Critic loop automatically improves test coverage

Role Registry:

Role	File	Task Prefix	Type
coordinator	roles/coordinator.md	(none)	orchestrator
strategist	roles/strategist.md	STRATEGY-*	pipeline
generator	roles/generator.md	TESTGEN-*	pipeline
executor	roles/executor.md	TESTRUN-*	pipeline
analyst	roles/analyst.md	TESTANA-*	pipeline

Three Pipelines:

Targeted (small scope changes):
  STRATEGY-001 → TESTGEN-001(L1 unit) → TESTRUN-001

Standard (progressive):
  STRATEGY-001 → TESTGEN-001(L1) → TESTRUN-001(L1) → TESTGEN-002(L2) → TESTRUN-002(L2) → TESTANA-001

Comprehensive (full coverage):
  STRATEGY-001 → [TESTGEN-001(L1) + TESTGEN-002(L2)](parallel) → [TESTRUN-001(L1) + TESTRUN-002(L2)](parallel) → TESTGEN-003(L3) → TESTRUN-003(L3) → TESTANA-001

Generator-Critic Loop:

TESTGEN → TESTRUN → (if coverage < target) → TESTGEN-fix → TESTRUN-2
                   (if coverage >= target) → next layer or TESTANA

Test Layer Definitions:

Layer	Coverage Target	Example
L1: Unit	80%	Unit tests, function-level tests
L2: Integration	60%	Integration tests, module interaction
L3: E2E	40%	End-to-end tests, user scenarios

Shared Memory (shared-memory.json):

Role	Field
strategist	test_strategy
generator	generated_tests
executor	execution_results, defect_patterns
analyst	analysis_report, coverage_history

Related Commands

• Claude Commands - Workflow
• Claude Commands - Session

Best Practices

1. Choose the right team type:

   • General tasks → team-coordinate
   • Full feature development → team-lifecycle
   • Issue batch processing → team-planex
   • Code review → team-review
   • Test coverage → team-testing

2. Leverage inner-loop roles: For roles with multiple same-prefix serial tasks, set inner_loop: true to let a single worker handle all tasks, avoiding repeated spawn overhead

3. Wisdom accumulation: All roles in team sessions accumulate knowledge to wisdom/ directory, subsequent tasks can reuse these patterns, decisions, and conventions

4. Fast-Advance: Simple linear successor tasks automatically skip coordinator to spawn directly, reducing coordination overhead

5. Checkpoint recovery: All team skills support session recovery, continue interrupted sessions via --resume or user command resume