Dispatch Parallel Agents for Independent Debugging

Dispatching Parallel Agents is a skill for handling multiple unrelated failures - different test files, different subsystems, different bugs - by dispatching one agent per independent problem domain and letting them work concurrently instead of investigating sequentially. The pattern runs in four steps: identify independent domains by grouping failures by what's broken (confirming fixing one won't affect another), create focused agent tasks each with a specific scope, a clear goal, explicit constraints, and an expected output format, dispatch them in parallel:

// In Claude Code / AI environment
Task("Fix agent-tool-abort.test.ts failures")
Task("Fix batch-completion-behavior.test.ts failures")
Task("Fix tool-approval-race-conditions.test.ts failures")
// All three run concurrently

and then review and integrate: read each returned summary, verify the fixes don't conflict, run the full test suite, and integrate all changes together.

Use this skill when 3+ test files are failing with different root causes, multiple subsystems are broken independently, each problem can be understood without context from the others, and there's no shared state between investigations. Do NOT use it when failures are related (fixing one might fix others - investigate together first), when understanding requires seeing the full system state, during exploratory debugging where you don't yet know what's broken, or when agents editing the same files or resources would interfere with each other.

Input is a set of independent failures (test files, subsystems, or bugs) to investigate; output is one agent prompt per domain, each following the same structure: a focused single problem domain, self-contained context (error messages, test names, what each test verifies), specific constraints (fix tests only, do not change production code, do not just increase timeouts - find the real issue), and a specific expected return format such as a summary of root cause and changes made. It names common mistakes to avoid when writing these prompts: a prompt scoped too broadly ("fix all the tests") loses the agent versus a specific file target; a prompt with no context ("fix the race condition") leaves the agent guessing versus pasting the actual error messages; a prompt with no constraints risks an agent refactoring unrelated code versus stating "fix tests only"; and a vague output request ("fix it") leaves you unable to verify what changed versus asking for a specific summary. A worked example from an actual debugging session shows three agents dispatched for six failures across three files - one replacing arbitrary timeouts with event-based waiting, one fixing an event-structure bug, one adding a wait for async tool execution - all integrated with zero conflicts and a green full suite.

Developers and agent orchestrators debugging multiple simultaneous, independent failures who want a repeatable dispatch-and-integrate pattern - focused scope, self-contained context, explicit constraints, specific output - rather than either investigating everything sequentially or dispatching agents with vague, overlapping instructions that risk conflicting edits.