Mmcp.market

task-coordination-strategies skill

by wshobson·wshobson/agents·40k stars·MIT

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.

A100/100content scan

Is the task-coordination-strategies skill safe?

Clean: nothing in its files matched our rules. We read 3 files in the folder on 2026-09-28.

No findings.

Install the task-coordination-strategies skill

A skill is a folder. Copy it into your agent's skills folder and the agent loads it when the task matches its description. 

git clone --depth 1 https://github.com/wshobson/agents.git /tmp/agents
mkdir -p ~/.claude/skills
cp -r /tmp/agents/plugins/agent-teams/skills/task-coordination-strategies ~/.claude/skills/task-coordination-strategies
available in every project

In the Claude apps, zip the folder and upload it from the Skills settings. The folder on GitHub

The instructions your agent would load

SKILL.md as published, without the frontmatter. Read it on GitHub

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

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

More skills from wshobson/agents

  • Aairflow-dag-patternsBuild production Apache Airflow DAGs with best practices for operators, sensors, testing, and deployment. Use when creating data pipelines, orchestrating workflows, or scheduling batch jobs.
  • Aangular-migrationMigrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applications, planning framework migrations, or modernizing legacy Angular code.
  • Aanti-reversing-techniquesUnderstand anti-reversing, obfuscation, and protection techniques encountered during software analysis. Use this skill when analyzing malware evasion techniques, when implementing anti-debugging protections for CTF challenges, when reverse engineering packed binaries, or when building security research tools that need to detect virtualized environments.
  • Aapi-design-principlesMaster REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.
  • Aarchitecture-decision-recordsWrite and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant technical decisions, reviewing past architectural choices, or establishing decision processes.
  • Aarchitecture-patternsImplement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use this skill when designing clean architecture for a new microservice, when refactoring a monolith to use bounded contexts, when implementing hexagonal or onion architecture patterns, or when debugging dependency cycles between application layers.
  • Aasync-python-patternsMaster Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.
  • Aauth-implementation-patternsMaster authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use when implementing auth systems, securing APIs, or debugging security issues.
  • Aavoid-ai-writingAudit and rewrite prose so it stops reading as machine-generated. Use this skill when asked to remove AI-isms, clean up AI writing, edit a draft for AI tells, audit a README, changelog, release note, PR description, or blog post for machine-sounding prose, or make text sound less like AI. Supports a detect-only mode, a rewrite mode, and an edit-in-place mode, with optional voice and context profiles.
  • Abacktesting-frameworksBuild robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developing trading algorithms, validating strategies, or building backtesting infrastructure.
  • Abazel-build-optimizationOptimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise codebases.
  • Abefore-you-buildPre-build product and feature risk review for founders, product managers, and AI-assisted builders. Use this skill when the user is about to build a landing page, MVP, SaaS product, internal tool, agent workflow, or major feature and needs to check demand, positioning, monetization, retention, trust, distribution, and adoption risk before implementation starts.

All agent skills → · MCP servers