systematic-debugging

Guide engineers through a four-phase root-cause investigation before implementing fixes.

Updated Apr 25, 2026
One-click install
npx skills add https://github.com/danmartinez78/echo-ghost-backup --skill systematic-debugging-danmartinez78
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/danmartinez78/echo-ghost-backup/tree/main/skills/software-development/systematic-debugging
Command: npx skills add https://github.com/danmartinez78/echo-ghost-backup --skill systematic-debugging-danmartinez78

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

Root-cause debugging is a disciplined, four-phase method to identify the actual cause of bugs and failures before implementing fixes, reducing thrashing and rework.

Core Features & Use Cases

  • Structured: follows Phase 1 (reproduce and read errors), Phase 2 (pattern analysis), Phase 3 (hypothesis testing), and Phase 4 (safe implementation and verification).
  • Reusable: applicable to runtime errors, test failures, performance issues, and integration glitches across software systems.
  • Guardrails: includes explicit shutdown criteria to avoid guessing and to require evidence before changes.

Quick Start

Describe the issue in detail and follow Phase 1 steps to begin the root-cause investigation.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is the best way to find the root cause of a bug before attempting fixes?

Root-cause debugging uses a four-phase investigation method to identify actual causes before implementing fixes, reducing thrashing and rework. The structured approach enforces data collection, pattern analysis, hypothesis testing, and controlled implementation with regression verification.

How do I debug runtime errors and test failures systematically?

Debug runtime errors and test failures by following a four-phase investigation: reproduce and read errors in Phase 1, perform pattern analysis in Phase 2, test hypotheses in Phase 3, and execute controlled implementation with regression verification in Phase 4.

Can I use this systematic debugging approach for performance problems and integration glitches?

Yes, systematic debugging is reusable and applicable to runtime errors, test failures, performance issues, and integration glitches across diverse software systems and workflows, enforcing evidence-based investigation before any code changes.

How does a hypothesis-driven debugging process prevent guessing during code fixes?

Hypothesis-driven debugging includes explicit shutdown criteria and guardrails that require evidence before code changes, preventing guessing. Phase 3 enforces hypothesis testing so engineers validate patterns before proceeding to controlled implementation.

Why should I investigate root causes instead of immediately patching unexpected behavior?

Investigating root causes before fixing unexpected behavior reduces rework and thrashing. The four-phase method requires reproducing errors, analyzing patterns, and testing hypotheses to ensure the actual cause is identified before any controlled implementation begins.

What are the limitations of a structured root-cause debugging workflow?

The structured root-cause debugging workflow requires strict adherence to its four phases, meaning engineers must complete data collection and pattern analysis before forming hypotheses, which may slow down urgent fixes but ensures evidence-based resolution and regression verification.