Debugging

Guide root-cause debugging through a four-phase investigation and verification process.

Updated Dec 23, 2025

Search Tags:#testing #debugging #defense-in-depth #verification #systematic #root-cause #stack-trace

Ready to run

npx skills add https://github.com/dige04/hieu-ccsetup --skill debugging-dige04

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: Debugging
Source: https://github.com/dige04/hieu-ccsetup/tree/main/config/skills/debugging
Command: npx skills add https://github.com/dige04/hieu-ccsetup --skill debugging-dige04

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Comprehensive debugging framework combining systematic investigation, root cause tracing, defense-in-depth validation, and verification protocols.

Core Features & Use Cases

Four-phase debugging process (Phase 1: Root Cause Investigation, Phase 2: Pattern Analysis, Phase 3: Hypothesis and Testing, Phase 4: Implementation) to ensure no fixes without root cause data.
Root cause tracing via backward call stack analysis with instrumentation guidance.
Defense-in-depth validation across entry, business logic, environment guards, and debug instrumentation layers.
Verification guidance to run fresh checks and collect evidence before claiming completion.
Load when confronting bugs, test failures, performance issues, or before declaring work complete.

Quick Start

Follow the four-phase debugging process to identify the root cause before applying fixes.

Frequently Asked Questions about Debugging

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

FAQPage Schema

What is systematic root cause debugging and when should I use it?▼

Systematic root cause debugging is a structured investigation process to uncover why software failures occur. You should use it when confronting bugs, test failures, performance issues, or integration problems to ensure no fixes are applied without root cause data.

How do I trace a root cause using backward call stack analysis?▼

Trace root causes by performing backward call stack analysis with targeted instrumentation. This method traces execution backward from the failure point, using instrumentation guidance to collect the data needed to identify the exact origin of the bug.

What is the best way to verify a software fix before declaring work complete?▼

The best way to verify a fix is by running fresh checks and collecting evidence. Defense-in-depth validation across entry, business logic, environment guards, and debug instrumentation layers ensures the fix is thoroughly verified before completion.

How do I find the root cause of a test failure before applying a fix?▼

Find the root cause of test failures by following a four-phase process: root cause investigation, pattern analysis, hypothesis testing, and implementation. This enforces systematic investigation to prevent applying fixes without underlying data.

Does this debugging process work for performance issues and integration problems?▼

Yes, this debugging framework applies across software debugging scenarios including performance issues and integration problems. It enforces a systematic four-phase process to uncover root causes and applies defense-in-depth validation regardless of the bug type.

What are the limitations of fixing bugs without pattern analysis and hypothesis testing?▼

Fixing bugs without pattern analysis and hypothesis testing risks addressing symptoms rather than root causes. Skipping these phases means lacking verification evidence and defense-in-depth validation, which can lead to recurring failures and unresolved integration issues.