systematic-debugging

Investigate root causes before implementing a single validated fix.

7|Updated Apr 7, 2026
One-click install
npx skills add https://github.com/chenziyang110/spec-kit-plus --skill systematic-debugging-chenziyang110
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/chenziyang110/spec-kit-plus/tree/main/templates/passive-skills/systematic-debugging
Command: npx skills add https://github.com/chenziyang110/spec-kit-plus --skill systematic-debugging-chenziyang110

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents wasted time and new bugs by requiring you to identify the true root cause of failures or unexpected behavior before proposing any changes.

Core Features & Use Cases

  • Root-cause-first debugging: Enforces the iron rule that you must not propose fixes until Phase 1 is complete.
  • A four-phase, pressure-resistant workflow: Guides you through investigation, pattern analysis, hypothesis testing, then implementation with verification and hard stop rules.
  • Anti-rationalization guardrails: Provides explicit red flags and failure-handling logic (including what to do when repeated fixes fail).
  • Use case: When a test, build, integration, or production error appears—especially under time pressure or after prior fixes failed—use this Skill to trace evidence, form a single hypothesis, and implement exactly one validated fix.

Quick Start

Use systematic-debugging when you hit a bug or failing test, then complete Phase 1 root-cause investigation before proposing any fixes.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I find the root cause of test failures instead of just patching symptoms?

Root-cause debugging requires completing a full investigation phase before proposing any fixes, tracing evidence to form a single hypothesis. This prevents symptom-whack-a-mole where quick patches introduce new bugs while leaving the true issue unresolved.

What is the best way to debug production incidents under time pressure without guessing?

Systematic debugging provides a pressure-resistant, four-phase workflow: investigation, pattern analysis, hypothesis testing, then implementation with verification. It enforces anti-rationalization guardrails and a hard stop rule after repeated fix failures to prevent guesswork during incidents.

Why do my repeated fixes keep failing on the same build or integration error?

Repeated fix failures indicate you are treating symptoms rather than the root cause. The stop-and-reanalyze rule triggers when fixes fail repeatedly, requiring you to abandon patching, return to evidence tracing, and form a new single hypothesis before attempting another fix.

How do I debug unexpected behavior by forming a testable hypothesis?

Form a single hypothesis from traced evidence during the investigation phase, then implement exactly one root-cause fix with verification. Testing one hypothesis at a time isolates variables and confirms the fix resolves the actual anomaly without introducing regressions.

When should I not use quick patches for performance or behavior anomalies?

Quick patches should be avoided whenever a test, build, integration, or production error appears, especially after prior fixes have failed. The iron rule prohibits proposing any changes until Phase 1 root-cause investigation is fully complete and evidence is traced.