
Parallel Debugging
FreeSystematically analyze complex bugs with competing hypotheses.
Free · Opens the source repo
What Parallel Debugging does
Parallel Debugging is a structured approach to resolving complex software issues by employing the Analysis of Competing Hypotheses (ACH) methodology. This skill is designed for developers and teams facing challenging bugs that may arise from multiple potential causes. By facilitating the generation of hypotheses and enabling parallel investigations, it helps in systematically identifying the root cause of issues that span across various modules or components.
The skill offers a comprehensive framework for hypothesis generation across six failure mode categories: Logic Error, Data Issue, State Problem, Integration Failure, Resource Issue, and Environment. This categorization allows users to pinpoint the nature of the problem more effectively, ensuring that no potential cause is overlooked. Each category outlines specific types of issues that can occur, such as incorrect conditional logic or memory leaks, providing a clear starting point for investigation.
In addition to hypothesis generation, Parallel Debugging emphasizes the importance of evidence collection. It defines what constitutes strong evidence, such as direct code references, and establishes confidence levels to assess the validity of each hypothesis. This structured approach mitigates confirmation bias, allowing teams to focus on the most promising leads based on the evidence gathered.
Finally, the skill includes a Result Arbitration Protocol that guides users through the process of categorizing results, comparing confirmed hypotheses, and determining the root cause of the issue. This ensures that the debugging process is thorough and systematic, ultimately leading to more reliable software solutions.
When to use it
Use this skill when initial debugging attempts have failed to identify the issue, or when the bug has multiple potential causes.
When not to use it
This skill may not be suitable for straightforward bugs with clear causes or when rapid fixes are needed without extensive analysis.
What you can build with it
Investigating a Multi-Module Bug
When a bug affects multiple components, use Parallel Debugging to generate hypotheses across various failure modes.
Systematic Root Cause Analysis
If initial attempts to debug a complex issue have failed, apply this skill to systematically analyze evidence and identify the root cause.
Avoiding Confirmation Bias
Utilize the structured approach of this skill to ensure that all potential causes are considered, reducing the risk of confirmation bias in debugging.
How to install Parallel Debugging
View source1. Install with the skills CLI
npx skills add wshobson/agents/parallel-debugging --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by wshobsonParallel Debugging
Framework for debugging complex issues using the Analysis of Competing Hypotheses (ACH) methodology with parallel agent investigation.
When to Use This Skill
- Bug has multiple plausible root causes
- Initial debugging attempts haven't identified the issue
- Issue spans multiple modules or components
- Need systematic root cause analysis with evidence
- Want to avoid confirmation bias in debugging
Hypothesis Generation Framework
Generate hypotheses across 6 failure mode categories:
1. Logic Error
- Incorrect conditional logic (wrong operator, missing case)
- Off-by-one errors in loops or array access
- Missing edge case handling
- Incorrect algorithm implementation
2. Data Issue
- Invalid or unexpected input data
- Type mismatch or coercion error
- Null/undefined/None where value expected
- Encoding or serialization problem
- Data truncation or overflow
3. State Problem
- Race condition between concurrent operations
- Stale cache returning outdated data
- Incorrect initialization or default values
- Unintended mutation of shared state
- State machine transition error
4. Integration Failure
- API contract violation (request/response mismatch)
- Version incompatibility between components
- Configuration mismatch between environments
- Missing or incorrect environment variables
- Network timeout or connection failure
5. Resource Issue
- Memory leak causing gradual degradation
- Connection pool exhaustion
- File descriptor or handle leak
- Disk space or quota exceeded
- CPU saturation from inefficient processing
6. Environment
- Missing runtime dependency
- Wrong library or framework version
- Platform-specific behavior difference
- Permission or access control issue
- Timezone or locale-related behavior
Evidence Collection Standards
What Constitutes Evidence
| Evidence Type | Strength | Example |
|---|---|---|
| Direct | Strong | Code at file.ts:42 shows if (x > 0) should be if (x >= 0) |
| Correlational | Medium | Error rate increased after commit abc123 |
| Testimonial | Weak | "It works on my machine" |
| Absence | Variable | No null check found in the code path |
Citation Format
Always cite evidence with file:line references:
**Evidence**: The validation function at `src/validators/user.ts:87`
does not check for empty strings, only null/undefined. This allows
empty email addresses to pass validation.
Confidence Levels
| Level | Criteria |
|---|---|
| High (>80%) | Multiple direct evidence pieces, clear causal chain, no contradicting evidence |
| Medium (50-80%) | Some direct evidence, plausible causal chain, minor ambiguities |
| Low (<50%) | Mostly correlational evidence, incomplete causal chain, some contradicting evidence |
Result Arbitration Protocol
After all investigators report:
Step 1: Categorize Results
- Confirmed: High confidence, strong evidence, clear causal chain
- Plausible: Medium confidence, some evidence, reasonable causal chain
- Falsified: Evidence contradicts the hypothesis
- Inconclusive: Insufficient evidence to confirm or falsify
Step 2: Compare Confirmed Hypotheses
If multiple hypotheses are confirmed, rank by:
- Confidence level
- Number of supporting evidence pieces
- Strength of causal chain
- Absence of contradicting evidence
Step 3: Determine Root Cause
- If one hypothesis clearly dominates: declare as root cause
- If multiple hypotheses are equally likely: may be compound issue (multiple contributing causes)
- If no hypotheses confirmed: generate new hypotheses based on evidence gathered
Step 4: Validate Fix
Before declaring the bug fixed:
- Fix addresses the identified root cause
- Fix doesn't introduce new issues
- Original reproduction case no longer fails
- Related edge cases are covered
- Relevant tests are added or updated
Frequently asked questions about Parallel Debugging
Similar skills
Agent Host Debug Logs
Analyze Agent Host debug logs for deeper insights.
Code OSS Dev - Launch + Debug
Launch and debug Code OSS with isolated profiles.
Phoenix CLI
Debug LLM applications with structured analysis tools.
Power Automate Debugging
Diagnose and fix Power Automate flow errors effectively.
Arize Trace
Inspect and export traces for LLM applications.
Runtime Behavior Probe
Investigate real runtime behavior with precision.
