/task-coordination-strategies

name: task-coordination-strategies
description: Decompose complex tasks, design dependency graphs, and coordinate multi-agent work with proper task descriptions and workload balancing. Use this skill when breaking down work for agent teams, managing task dependencies, or monitoring team progress.
version: 1.0.2

Task Coordination Strategies

Strategies for decomposing complex tasks into parallelizable units, designing dependency graphs, writing effective task descriptions, and monitoring workload across agent teams.

When to Use This Skill

• Breaking down a complex task for parallel execution
• Designing task dependency relationships (blockedBy/blocks)
• Writing task descriptions with clear acceptance criteria
• Monitoring and rebalancing workload across teammates
• Identifying the critical path in a multi-task workflow

Task Decomposition Strategies

By Layer

Split work by architectural layer:

• Frontend components
• Backend API endpoints
• Database migrations/models
• Test suites

**Best for**: Full-stack features, vertical slices

By Component

Split work by functional component:

• Authentication module
• User profile module
• Notification module

**Best for**: Microservices, modular architectures

By Concern

Split work by cross-cutting concern:

• Security review
• Performance review
• Architecture review

**Best for**: Code reviews, audits

By File Ownership

Split work by file/directory boundaries:

• `src/components/` — Implementer 1
• `src/api/` — Implementer 2
• `src/utils/` — Implementer 3

**Best for**: Parallel implementation, conflict avoidance

Dependency Graph Design

Principles

1. **Minimize chain depth** — Prefer wide, shallow graphs over deep chains 2. **Identify the critical path** — The longest chain determines minimum completion time 3. **Use blockedBy sparingly** — Only add dependencies that are truly required 4. **Avoid circular dependencies** — Task A blocks B blocks A is a deadlock

Patterns

**Independent (Best parallelism)**:

Task A ─┐
Task B ─┼─→ Integration
Task C ─┘

**Sequential (Necessary dependencies)**:

Task A → Task B → Task C

**Diamond (Mixed)**:

        ┌→ Task B ─┐
Task A ─┤          ├→ Task D
        └→ Task C ─┘

Using blockedBy/blocks

TaskCreate: { subject: "Build API endpoints" }         → Task #1
TaskCreate: { subject: "Build frontend components" }    → Task #2
TaskCreate: { subject: "Integration testing" }          → Task #3
TaskUpdate: { taskId: "3", addBlockedBy: ["1", "2"] }  → #3 waits for #1 and #2

Task Description Best Practices

Every task should include:

1. **Objective** — What needs to be accomplished (1-2 sentences) 2. **Owned Files** — Explicit list of files/directories this teammate may modify 3. **Requirements** — Specific deliverables or behaviors expected 4. **Interface Contracts** — How this work connects to other teammates' work 5. **Acceptance Criteria** — How to verify the task is done correctly 6. **Scope Boundaries** — What is explicitly out of scope

Template

## Objective
Build the user authentication API endpoints.

## Owned Files
- src/api/auth.ts
- src/api/middleware/auth-middleware.ts
- src/types/auth.ts (shared — read only, do not modify)

## Requirements
- POST /api/login — accepts email/password, returns JWT
- POST /api/register — creates new user, returns JWT
- GET /api/me — returns current user profile (requires auth)

## Interface Contract
- Import User type from src/types/auth.ts (owned by implementer-1)
- Export AuthResponse type for frontend consumption

## Acceptance Criteria
- All endpoints return proper HTTP status codes
- JWT tokens expire after 24 hours
- Passwords are hashed with bcrypt

## Out of Scope
- OAuth/social login
- Password reset flow
- Rate limiting

Workload Monitoring

Indicators of Imbalance

| Signal | Meaning | Action | | -------------------------- | ------------------- | --------------------------- | | Teammate idle, others busy | Uneven distribution | Reassign pending tasks | | Teammate stuck on one task | Possible blocker | Check in, offer help | | All tasks blocked | Dependency issue | Resolve critical path first | | One teammate has 3x others | Overloaded | Split tasks or reassign |

Rebalancing Steps

1. Call `TaskList` to assess current state 2. Identify idle or overloaded teammates 3. Use `TaskUpdate` to reassign tasks 4. Use `SendMessage` to notify affected teammates 5. Monitor for improved throughput