AI & agents · Automation
dispatching-parallel-agents
/dispatching-parallel-agents
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
For whom
- Author
- HarmAalbers ↗
- Repository
- claude-requirements-framework ↗
- Licence
- MIT
- Last repository change
- 09.10.2026
Assessment and security
100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
Deprecation
No signals detected. Repository changed on 09.10.2026, without references to retired models or APIs.
Licence
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
Original author description
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
How it works
- Overview
- When to Use
- The Pattern
- Agent Prompt Structure
- Common Mistakes
- When NOT to Use
- Verification
- Key Benefits
Original SKILL.md headings · 140 lines, 680 words
SKILL.md preview
---
name: dispatching-parallel-agents
description: Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
git_hash: 307b927
---
# Dispatching Parallel Agents
## Overview
When you have multiple unrelated failures (different test files, different subsystems, different bugs), investigating them sequentially wastes time. Each investigation is independent and can happen in parallel.
**Core principle:** Dispatch one agent per independent problem domain. Let them work concurrently.
## When to Use
```dot
digraph when_to_use {
"Multiple failures?" [shape=diamond];
"Are they independent?" [shape=diamond];
"Single agent investigates all" [shape=box];
"One agent per problem domain" [shape=box];
"Can they work in parallel?" [shape=diamond];
"Sequential agents" [shape=box];
"Parallel dispatch" [shape=box];
"Multiple failures?" -> "Are they independent?" [label="yes"];
"Are they independent?" -> "Single agent investigates all" [label="no - related"];
"Are they independent?" -> "Can they work in parallel?" [label="yes"];
"Can they work in parallel?" -> "Parallel dispatch" [label="yes"];
"Can they work in parallel?" -> "Sequential agents" [label="no - shared state"];
}
```
**Use when:**
- 3+ test files failing with different root causes
- Multiple subsystems broken independently
- Each problem can be understood without context from others
- No shared state between investigations
**Don't use when:**
- Failures are related (fix one might fix others)
- Need to understand full system state
- Agents would interfere with each other (editing same files)
## The Pattern
### 1. Identify Independent Domains
Group failures by what's broken:
- File A tests: Authentication flow
- File B tests: Data validation
- File C tests: API endpoints
Each domain is independent — fixing authentication doesn't affect API endpoint tests.
### 2. Create Focused Agent Tasks
Each agent gets:
- **Specific scope:** One test file or subsystem
- **Clear goal:** Make these tests pass
- **Constraints:** Don't change other code
- **Expected output:** Summary of what you found and fixed
### 3. Dispatch in Parallel
```python
# Using Claude Code's Task tool
Task("Fix test_auth.py failures") # Agent 1
Task("Fix test_validation.py failures") # Agent 2
Task("Fix test_api.py failures") # Agent 3
# All three run concurrently
```
**Alternative:** For review tasks, consider using Agent Teams (TeamCreate) which provide built-in cross-validation and shared task lists.
### 4. Review and Integrate
When agents return:
- Read each summary
- Verify fixes don't conflict
- Run full test suite
- Integrate all changes
## Agent Prompt Structure
Good agent prompts are:
1. **Focused** — One clear problem domain
2. **Self-contained** — All context needed to understand the problem
3. **Specific about output** — What should the agent return?
```markdown
Fix the 3 failing tests in tests/test_auth.py:
1. "test_login_with_expired_token" - expects 401, gets 200
2. "test_refresh_token_rotation" - token not rotated after use
3. "test_concurrent_sessions" - expects 3 sessions, gets 0
These may be timing or state issues. Your task:
1. Read the test file and understand what each test verifies
2. Identify root cause - timing issues or actual bugs?
3. Fix by addressing root cause (not just increasing timeouts)
Do NOT change tests in other files.
Return: Summary of what you found and what you fixed.
```
## Common Mistakes
**Too broad:** "Fix all the tests" — agent gets lost
**Specific:** "Fix tests/test_auth.py" — focused scope
**No context:** "Fix the race condition" — agent doesn't know where
**Context:** Paste the error messages and test names
**No constraints:** Agent might refactor everything
**Constraints:** "Do NOT change production code" or "Fix tests only"
**Vague output:** "Fix it" — you don't know what changed
**Specific:** "Return summary of root cause and changes"
## When NOT to Use
**Related failures:** Fixing one might fix others — investigate together first
**Need full context:** Understanding requires seeing entire system
**Exploratory debugging:** You don't know what's broken yet
**Shared state:** Agents would interfere (editing same files, using same resources)
## Verification
After agents return:
1. **Review each summary** — Understand what changed
2. **Check for conflicts** — Did agents edit same code?
3. **Run full suite** — Verify all fixes work together
4. **Spot check** — Agents can make systematic errors
## Key Benefits
1. **Parallelization** — Multiple investigations happen simultaneously
2. **Focus** — Each agent has narrow scope, less context to track
3. **Independence** — Agents don't interfere with each other
4. **Speed** — 3 problems solved in time of 1
Files in this package (2)
- SKILL.md 5 KB
- SKILL.md.j2 5 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · HarmAalbers/claude-requirements-framework | 100 | MIT |
| jjuraszek/pi-gauntlet | 100 | MIT |
| osmontero/opencode-skills | 100 | MIT |
| coco-research/coco | 100 | MIT |
| FrancoStino/opencode-skills-collection | 100 | MIT |
| seaworld008/commonly-used-high-value-skills | 100 | MIT |
| rootcastleco/rei-skills | 100 | MIT |
| nikospavlopoulos/devops-mutant-powers | 100 | MIT |
| Richicinschi/studio-os | 100 | MIT |
Database snapshot: 13.11.2026 · package version 133f2fc39612 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100parallel
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies - 100sr-dispatching-parallel-agents
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies