debug-systematically

Enforces a four-phase debugging workflow of reproduce, locate, hypothesize, then fix.

96|8|Updated Aug 13, 2026
One-click install
npx skills add https://github.com/pingfanfan/hello-dsh --skill debug-systematically-pingfanfan
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: debug-systematically
Source: https://github.com/pingfanfan/hello-dsh/tree/main/examples/skills/debug-systematically
Command: npx skills add https://github.com/pingfanfan/hello-dsh --skill debug-systematically-pingfanfan

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? When facing bugs, test failures, or regressions, developers often jump straight to editing code and hope the symptom disappears, which hides the root cause and lets it resurface elsewhere. This Skill forces a disciplined sequence: reproduce the issue reliably, locate the exact file and line, form a falsifiable root-cause hypothesis, and only then write a fix with a regression test. ## Core Features & Use Cases - Four gated phases: Reproduction, localization, hypothesis with falsification, and fix — each phase has a required output and you cannot skip ahead. - Root-cause discipline: Prohibits code changes before the cause is identified, and requires stating the cause in the form "because <code> under <condition> does <behavior>, we observe <symptom>". - Pitfall detection: Flags common anti-patterns like fixing symptoms instead of causes, trusting stale documentation, changing multiple variables at once, and believing green tests prove correctness. - Use Case: A test suite suddenly fails after a refactor. Instead of tweaking code until it passes, you first reproduce the failure with a stable command, bisect to the offending line, write a failing test that captures the regression, then fix and verify the full suite passes. ## Quick Start Use the debug-systematically skill to investigate why my login endpoint returns a 500 error only under concurrent requests.

Frequently Asked Questions about debug-systematically

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

FAQPage Schema
How do I debug a bug systematically instead of guessing?▼

Follow four gated phases: first reproduce the issue with a stable command, then localize the exact file and line, then state a falsifiable root-cause hypothesis, and only then fix. Never modify code before the root cause is identified.

How to find the root cause of a test failure?▼

Read the stack trace from the deepest frame outward, print actual values at suspected points instead of assuming them, and bisect by commenting out half the code or reverting half the commits. You have located the cause when you can predict how a change will alter the symptom.

What should I do when a bug cannot be reproduced reliably?▼

Prioritize making it reproducible before anything else, since an unreproducible bug cannot have a verified fix. Investigate concurrency, caching, timing, and environment differences, and check the boundary conditions where the bug does not occur.

Why is fixing code before finding the root cause risky?▼

Changing code without a known cause may make the symptom disappear while the root cause remains, resurfacing later in a harder-to-diagnose form. It also leaves you unable to verify the fix, since you never established a reliable reproduction.

When should I stop debugging and ask for help?▼

Stop after three failed attempts in the same hypothesis direction, when the fix touches an unfamiliar subsystem, or when reproduction is impossible. When asking, provide reproduction steps, ruled-out possibilities, your current hypothesis, and the exact point where you are stuck.