dispatching-parallel-agents

Dispatch parallel agents to investigate independent failures across test files.

Updated Nov 24, 2025
One-click install
npx skills add https://github.com/ByronWilliamsCPA/.claude --skill dispatching-parallel-agents-byronwilliamscpa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dispatching-parallel-agents
Source: https://github.com/ByronWilliamsCPA/.claude/tree/main/.claude/skills/dispatching-parallel-agents
Command: npx skills add https://github.com/ByronWilliamsCPA/.claude --skill dispatching-parallel-agents-byronwilliamscpa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

When you have multiple independent failures (such as unrelated failing test files, separate broken subsystems, or decoupled audit findings), investigating and fixing them sequentially wastes time and consumes unnecessary context. Each independent issue can be worked on in parallel without shared state or dependencies, drastically reducing total resolution time.

Core Features & Use Cases

  • Dual fan-out modes: Supports remediation fan-outs for code/config edits and read-only evaluation fan-outs for audits, with mode-specific safeguards for each.
  • Pre-dispatch feasibility checks: Validates that all target tasks are live, in scope, and not already completed or being worked on by concurrent actors to avoid wasted agent effort.
  • Collision and concurrency safeguards: Includes rules for shared repository safety, including handling shared worktrees, commit-time index races, and namespace allocation to prevent write conflicts.
  • Structured agent prompts: Provides templates for focused, self-contained agent tasks with clear scope, constraints, and output requirements to ensure consistent, usable results.
  • Use case: If 3+ unrelated test files are failing with different root causes, use this skill to dispatch one specialized agent per test file to fix them concurrently, rather than investigating each one sequentially.

Quick Start

Use the dispatching-parallel-agents skill to fix all unrelated failing test files in the current repository in parallel.

Frequently Asked Questions about dispatching-parallel-agents

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I fix multiple unrelated failing test files concurrently instead of sequentially?

To fix unrelated failing test files concurrently, use parallel agent fan-out to dispatch one specialized agent per test file. This requires pre-dispatch feasibility gates to ensure targets are live, in scope, and not already being worked on by concurrent actors.

When should I use parallel agents for task fan-out?

Use parallel agents for task fan-out when you have 3 or more decoupled issues with no shared state or sequential dependencies, such as independent broken subsystems or disjoint audit tasks, to drastically reduce total resolution time and context overhead.

How do parallel agents handle write collisions in a shared repository?

Parallel agents handle write collisions in a shared repository using mode-specific safeguards that manage shared worktrees, prevent commit-time index races, and allocate namespaces to avoid write conflicts during concurrent code and config edits.

Can I run read-only evaluation fan-outs for audit tasks without write conflicts?

Yes, you can run read-only evaluation fan-outs for audit tasks using mode-specific safeguards. This mode prevents findings loss and avoids write conflicts entirely by restricting agents to evaluation rather than code or config edits.

What are the limitations of using concurrent debugging for multiple subsystem failures?

Concurrent debugging for multiple subsystem failures is limited by shared state and sequential dependencies; if issues are coupled rather than decoupled, parallel agent dispatch is not viable and sequential investigation remains necessary.

Does dispatching parallel agents require pre-dispatch feasibility checks?

Yes, dispatching parallel agents requires pre-dispatch feasibility checks to validate that all target tasks are live, in scope, and not already completed or being worked on by concurrent actors, preventing wasted agent effort before dispatch.