systematic-debugging

Diagnose technical bugs through a four-phase root cause investigation framework.

21|9|Updated May 27, 2026
One-click install
npx skills add https://github.com/cq112233/unibestX --skill systematic-debugging-cq112233
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/cq112233/unibestX/tree/main/.agents/skills/systematic-debugging
Command: npx skills add https://github.com/cq112233/unibestX --skill systematic-debugging-cq112233

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This skill prevents the common pitfall of symptom-based patching, which often leads to wasted time, recurring issues, and the introduction of new bugs. It provides a structured, pressure-resistant methodology to ensure you identify and resolve the actual root cause of any technical failure.

Core Features & Use Cases

  • Four-Phase Framework: Guides you through investigation, pattern analysis, hypothesis testing, and implementation.
  • Anti-Shortcut Guardrails: Explicitly identifies and blocks common debugging traps like shotgun debugging or skipping tests under time pressure.
  • Root Cause Tracing: Includes techniques for tracing data flow and adding diagnostic instrumentation to complex, multi-component systems.
  • Use Case: Use this when you are facing a persistent production bug, a flaky test suite, or a complex integration failure where previous attempts to fix the issue have failed.

Quick Start

Load the systematic-debugging skill and follow the phase-by-phase checklist to investigate the root cause of the current test failure.

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 debug a persistent production bug where previous fixes failed?

To debug a persistent production bug, use a systematic debugging framework that traces the root cause through a four-phase process: investigation, pattern analysis, hypothesis testing, and implementation, preventing ineffective symptom-based patching.

How do I troubleshoot a flaky test suite without skipping tests under time pressure?

Troubleshoot a flaky test suite by applying anti-shortcut guardrails that block skipping tests, instead guiding you through evidence-based hypothesis testing and multi-layer defensive checks to isolate the actual root cause.

Why does symptom-based patching often lead to recurring technical failures?

Symptom-based patching leads to recurring technical failures because it addresses superficial effects rather than the root cause, often introducing new bugs and wasting time when facing complex integration issues or system failures.

How do I trace data flow and add diagnostic instrumentation to complex multi-component systems?

Trace data flow and add diagnostic instrumentation during the investigation and pattern analysis phases of systematic debugging, enabling evidence-based hypothesis testing to resolve complex integration issues.

When should I use a systematic root-cause investigation instead of shotgun debugging?

Use systematic root-cause investigation instead of shotgun debugging when facing complex integration failures, production incidents, or flaky test suites where unstructured changes are ineffective and anti-shortcut guardrails are needed.