Debugging

Enforce root-cause investigation before fixing software bugs across multi-component systems.

1|Updated Jan 25, 2026
One-click install
npx skills add https://github.com/hoanghd218/tranvanhoang.com --skill debugging-hoanghd218
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Debugging
Source: https://github.com/hoanghd218/tranvanhoang.com/tree/main/.claude/skills/debugging
Command: npx skills add https://github.com/hoanghd218/tranvanhoang.com --skill debugging-hoanghd218

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Systematic debugging framework that enforces root-cause analysis before fixes to reduce wasted effort and regression risk.

Core Features & Use Cases

  • Systematic Debugging with four phases (Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, Implementation)
  • Root Cause Tracing to locate original trigger
  • Defense-in-Depth for multi-layer validation
  • Verification before completion
  • Use cases: debugging flaky tests, performance issues, unexpected behavior, build failures across multi-component systems

Quick Start

Identify the symptom, reproduce consistently, and gather evidence before proposing fixes.

Frequently Asked Questions about Debugging

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

FAQPage Schema
How do I systematically debug flaky tests and unexpected behavior across multi-component systems?

Systematic debugging enforces root-cause investigation across multi-component systems by applying four phases: root cause investigation, pattern analysis, hypothesis testing, and implementation. It targets flaky tests, performance issues, and unexpected behavior using evidence collection and data flow tracing.

What is the best way to trace root causes in software issues before applying fixes?

Root cause tracing locates the original trigger of software issues before fixes are applied. By enforcing evidence collection and reproducibility, this systematic debugging approach reduces wasted effort and regression risk by validating hypotheses through structured data-flow analysis.

How does defense-in-depth validation work when debugging build failures?

Defense-in-depth validation applies multi-layer verification to debugging build failures and performance problems. It enforces evidence collection and structured data-flow analysis across multi-component systems, requiring verification before claiming success to prevent recurring issues.

What steps should I follow to reproduce consistently and gather evidence for a bug?

To debug a bug, first identify the symptom, reproduce it consistently, and gather evidence before proposing fixes. This systematic debugging framework then moves through pattern analysis, hypothesis testing, and implementation phases to ensure root-cause verification.

Can I use this systematic debugging approach for performance problems in Node.js applications?

Yes, this systematic debugging approach applies to performance problems in Node.js applications. It requires npm as a dependency and uses scripts and references to enforce root-cause investigation, evidence collection, and data-flow tracing across multi-component systems.

Why does fixing a symptom without root-cause investigation increase regression risk?

Fixing symptoms without root-cause investigation increases regression risk because the original trigger remains unresolved. Systematic debugging enforces evidence collection, reproducibility, and defense-in-depth validation before implementation to ensure the root cause is eliminated.