systematic-debugging

Enforce root-cause-first debugging with four ordered phases and evidence gathering.

8|1|Updated Mar 1, 2026
One-click install
npx skills add https://github.com/JoeCP17/LLM-Dot-files --skill systematic-debugging-joecp17
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/JoeCP17/LLM-Dot-files/tree/main/claude/skills/superpowers/systematic-debugging
Command: npx skills add https://github.com/JoeCP17/LLM-Dot-files --skill systematic-debugging-joecp17

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents wasted time and new bugs by forcing you to investigate the real root cause of failures and unexpected behavior before attempting any fixes.

Core Features & Use Cases

  • Four-phase debugging workflow: Root cause investigation, pattern analysis, single-hypothesis testing, then implementation with verification.
  • Pressure-resistant rules: Explicit mandates like “ALWAYS find root cause before attempting fixes” and “NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST”.
  • Common debugging scenarios: Test failures, production bugs, unexpected integration behavior, build failures, performance issues, and flaky timing problems—especially when you’re tempted to “just ship a quick patch.”

Quick Start

Follow the four phases in order—starting with Phase 1 root cause investigation—before you propose or implement any fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I find the root cause of test failures before applying a fix?

Root cause analysis for test failures requires gathering evidence and testing a single hypothesis minimally before implementation. You must complete four ordered phases, starting with investigation, to stop applying symptom patches that waste time and introduce new defects.

What is the best way to debug production incidents without introducing new bugs?

Debugging production incidents effectively means enforcing root cause investigation first. By completing pattern analysis and verifying implementation with tests or a clear validation step, you avoid quick patches that cause unexpected behavior across multi-component systems.

How do I stop fixing symptoms instead of the actual root cause during incident response?

To stop fixing symptoms during incident response, follow a pressure-resistant workflow that mandates finding the root cause before any fixes. This method requires evidence gathering and single-hypothesis testing to prevent wasted time and new defects.

Can I use root cause analysis for build failures and performance regressions?

Root cause analysis applies to build failures, performance regressions, and flaky timing problems across single or multi-component systems. It enforces a four-phase debugging workflow to investigate technical failures thoroughly before you change code.

Why should I test a single hypothesis minimally when debugging unexpected behavior?

Testing a single hypothesis minimally during debugging isolates variables and confirms the root cause without introducing side effects. This disciplined approach prevents wasted effort on symptom patches and ensures implementation is verified by tests.

When should I not use quick patches for technical failures and integration issues?

You should never use quick patches for technical failures or integration issues when you lack root cause investigation. Applying symptom patches without evidence gathering and hypothesis testing wastes time and risks introducing new defects into multi-component systems.