systematic-debugging

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

3|Updated Feb 2, 2026
One-click install
npx skills add https://github.com/Dethon/ai-dev-flow --skill systematic-debugging-dethon
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Dethon/ai-dev-flow/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/Dethon/ai-dev-flow --skill systematic-debugging-dethon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured, repeatable approach to debugging complex software by following a four-phase process that forces root-cause analysis before implementing fixes.

Core Features & Use Cases

  • Phase-driven debugging blueprint that reduces time-to-resolution.
  • Includes lateral references like root-cause tracing, defense-in-depth, and pattern analysis to prevent regressions.
  • Use cases: debugging production bugs, flaky tests, and deep stack traces; works across codebases.

Quick Start

Run the systematic-debugging skill to guide you through Phase 1: Root Cause Investigation, then Phase 2: Pattern Analysis, Phase 3: Hypothesis and Testing, and Phase 4: Implementation. See the included examples in the skill directory for concrete steps.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I systematically debug complex software bugs instead of guessing fixes?

Systematic debugging enforces a four-phase workflow—Root Cause Investigation, Pattern Analysis, Hypothesis Testing, and Implementation—to resolve bugs by tracing root causes before applying fixes. It provides structured checklists and fail-fast validation.

What is the best way to diagnose flaky tests and deep stack traces?

Diagnosing flaky tests and deep stack traces requires systematic root-cause investigation followed by pattern analysis. This approach guides you through forming hypotheses and testing them before implementation, ensuring fixes are architecture-conscious and defensible.

How do I prevent regressions when fixing production failures?

Preventing regressions during production failure fixes involves using defense-in-depth and pattern analysis. The systematic debugging process requires root-cause tracing and fail-fast validation before implementation, ensuring the original failure is resolved without introducing new issues.

Can I apply a structured debugging process across any codebase?

Yes, this systematic debugging workflow applies to any codebase. It provides a repeatable, phase-based blueprint for resolving production bugs, flaky tests, and complex stack traces by enforcing structured guidance and root-cause analysis regardless of the specific technology.

Why should I use root-cause investigation before implementing a bug fix?

Root-cause investigation before implementation ensures you resolve the actual defect rather than treating symptoms. The four-phase debugging workflow forces this analysis to guarantee architecture-conscious, defensible fixes that reduce time-to-resolution and prevent future regressions.