systematic-debugging

Identify root causes of bugs using a four-phase debugging process.

1|Updated Feb 22, 2026
One-click install
npx skills add https://github.com/involvex/awesome-github-app --skill systematic-debugging-involvex
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/involvex/awesome-github-app/tree/main/.claude/skills/systematic-debugging
Command: npx skills add https://github.com/involvex/awesome-github-app --skill systematic-debugging-involvex

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps teams avoid symptom fixes by enforcing a four-phase, root-cause-driven debugging process.

Core Features & Use Cases

  • Phase 1: Root Cause Investigation (reproduce, gather evidence, document findings)
  • Phase 2: Pattern Analysis (compare with working references, identify differences)
  • Phase 3: Hypothesis and Testing (form a single hypothesis, test minimally)
  • Phase 4: Implementation (create failing test, implement fix, verify)
  • Defense-in-depth guidance and common anti-patterns to resist rush decisions

Quick Start

Start by loading the skill and following Phase 1's root-cause checklist before proposing 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 a bug instead of just fixing the symptoms?

Root cause analysis requires reproducing the issue, gathering evidence, and comparing against working references before implementing fixes. This systematic debugging workflow enforces a four-phase process to identify actual root causes and prevent superficial symptom patches.

What is the best way to debug production incidents without rushing to a quick fix?

Debugging production incidents benefits from a phased workflow that mandates evidence gathering and pattern analysis before hypothesis testing. Defense-in-depth guidance helps resist rush decisions by enforcing root cause investigation and validating changes with failing tests.

How do I systematically debug flaky tests that have misleading symptoms?

Debugging flaky tests involves reproducing failures, documenting evidence, and comparing with working references to identify differences. Form a single hypothesis, test minimally, implement the fix with a failing test, and verify the resolution thoroughly.

Can I use this systematic debugging process for general software bugs and failures?

Yes, this debugging process applies to software bugs, production incidents, and flaky tests. It enforces phased analysis including root cause investigation, pattern comparison, minimal hypothesis testing, and implementation with validation tests for any failure scenario.

What are common anti-patterns to avoid during root cause analysis?

Common debugging anti-patterns include skipping evidence gathering, proposing fixes before completing root cause investigation, testing multiple hypotheses simultaneously, and neglecting to create failing tests. Defense-in-depth guidance helps resist these rush decisions.