systematic-debugging

Diagnose software bugs through a four-phase root cause investigation process.

Updated Jan 28, 2026
One-click install
npx skills add https://github.com/CodingHeader/MySkills --skill systematic-debugging-codingheader
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/CodingHeader/MySkills/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/CodingHeader/MySkills --skill systematic-debugging-codingheader

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic Debugging provides a disciplined, four-phase framework to diagnose bugs, reproduce root causes, and prevent rash fixes that mask symptoms.

Core Features & Use Cases

  • Phase 1: Root Cause Investigation — read errors, reproduce, check recent changes, and gather evidence before proposing fixes.
  • Phase 2: Pattern Analysis — identify differences, compare against references, and understand dependencies.
  • Phase 3: Hypothesis and Testing — form a single hypothesis, test minimally, and verify before continuing.
  • Phase 4: Implementation — create failing tests, implement a single fix, and verify success; apply defense-in-depth when needed.
  • Red flags and defense-in-depth guidance help teams avoid shortcuts and ensure robust outcomes.

Quick Start

Load the skill and begin Phase 1 Root Cause Investigation before proposing any fixes.

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 a software bug instead of just fixing the symptom?

Root cause debugging requires gathering evidence, reproducing the issue, and analyzing patterns before proposing fixes. This approach enforces a four-phase process to investigate failures, test single hypotheses, and apply defense-in-depth validations to prevent symptom masking.

What is the best way to troubleshoot test failures and production bugs systematically?

Systematic troubleshooting uses a phase-based approach: investigate root causes by checking recent changes, analyze dependencies and patterns, form a single hypothesis, and implement fixes with failing tests to verify success across diverse codebases.

How do I stop applying rash fixes that mask symptoms during debugging?

To stop rash fixes, enforce a disciplined debugging process that requires completing four phases: root cause investigation, pattern analysis, hypothesis testing, and implementation. Use defense-in-depth validations and watch for red flags to ensure robust outcomes.

Does systematic debugging work for any codebase or only specific software environments?

Systematic debugging applies to any software issue across diverse codebases and teams. It handles test failures, production bugs, or unexpected behavior by enforcing a structured four-phase process regardless of the specific environment.

What are the four phases of debugging used to eliminate root causes?

The four debugging phases are Root Cause Investigation, Pattern Analysis, Hypothesis and Testing, and Implementation. Completing these phases ensures you gather evidence, test minimally, create failing tests, and apply defense-in-depth to prevent future issues.

Why should I create failing tests before implementing a bug fix?

Creating failing tests before implementing a fix verifies the root cause and ensures the single proposed fix resolves the exact issue. This phase-based testing approach prevents symptom fixes and validates success before considering the debugging process complete.