systematic-debugging

Enforce a four-phase root-cause investigation framework for software debugging.

146|31|Updated Jul 25, 2025
One-click install
npx skills add https://github.com/bobmatnyc/claude-mpm --skill systematic-debugging-bobmatnyc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/bobmatnyc/claude-mpm/tree/main/src/claude_mpm/skills/bundled/debugging/systematic-debugging
Command: npx skills add https://github.com/bobmatnyc/claude-mpm --skill systematic-debugging-bobmatnyc

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill eliminates the inefficiency and frustration of random code changes, quick fixes, and symptom-based debugging that lead to recurring bugs and wasted time. It enforces a methodical, root-cause-driven approach to ensure permanent solutions.

Core Features & Use Cases

  • Four-Phase Framework: Guides you through investigation, pattern analysis, hypothesis formation, and verified implementation, ensuring the root cause is always found before any fix is attempted.
  • Anti-Pattern Recognition: Explicitly identifies and prevents common debugging mistakes like "quick fixes for now" or "just try changing X and see if it works," saving hours of thrashing.
  • Pressure-Resistant Process: Designed to maintain debugging discipline even under intense time pressure, preventing shortcuts that mask deeper issues and lead to future problems.
  • Use Case: When a critical bug is reported under tight deadlines, use this Skill to resist the urge for quick patches, systematically diagnose the root cause, and implement a permanent, verified fix, preventing its recurrence.

Quick Start

Use the systematic-debugging skill to investigate why test_user_authentication.py is intermittently failing.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I stop fixing symptoms instead of root causes when debugging?

Root-cause debugging requires a four-phase framework: investigate to find the actual source, analyze patterns across the codebase, form and test hypotheses, then implement verified fixes. This prevents recurring bugs by addressing the underlying problem, not just masking symptoms.

What's the best way to debug bugs that keep coming back?

Recurring bugs signal symptom-based fixes. Use systematic investigation to identify the root cause before any change, test one modification at a time with reproducible evidence, and verify the fix prevents recurrence. This permanent approach replaces guesswork and quick patches.

How do I investigate bugs when under time pressure?

Time pressure tempts quick fixes that mask deeper issues. A formal debugging process with mandatory root-cause investigation, pattern analysis, and hypothesis testing maintains discipline under stress, preventing shortcuts that cause future problems and waste more time later.

Can I debug complex failures across multiple components systematically?

Multi-component failures require disciplined investigation to isolate the actual source. The four-phase framework—investigation, pattern analysis, hypothesis formation, and verified implementation—cuts through complexity by enforcing evidence-based reasoning instead of random code changes.

Why do my bug fixes create new problems elsewhere?

Unfocused fixes often target symptoms in one area while leaving the root cause intact in another. Systematic debugging with one-change-at-a-time testing and reproducible evidence gathering ensures fixes address the actual problem and don't introduce side effects.

How do I know when I've found the real bug, not just a symptom?

Root-cause investigation distinguishes symptoms from causes through pattern analysis and hypothesis testing. Once you've traced the failure back through the codebase to its source and verified the fix prevents recurrence, you've found the real bug.