systematic-debugging

Diagnose and isolate root causes of software bugs and test failures.

154|1|Updated Feb 20, 2026
One-click install
npx skills add https://github.com/haojing8312/WorkClaw --skill systematic-debugging-haojing8312
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/haojing8312/WorkClaw/tree/main/.claude/skills/systematic-debugging
Command: npx skills add https://github.com/haojing8312/WorkClaw --skill systematic-debugging-haojing8312

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Random quick fixes and guesswork hide true causes, waste time, introduce regressions, and prolong outages; this Skill guides a disciplined, repeatable process to find and fix root causes rather than symptoms.

Core Features & Use Cases

  • Four-phase, stepwise workflow: mandatory Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, and Implementation.
  • Reproducibility and instrumentation: reproduce issues consistently, add diagnostics across component boundaries, and collect evidence before changing code.
  • Hypothesis-driven minimal changes: test one variable at a time, create a failing reproduction, and verify fixes before proceeding.
  • Defense-in-depth: add validation at multiple layers to make classes of bugs structurally impossible.
  • Adapts to contexts: useful for production incidents, flaky tests, build or integration failures, and multi-component tracing.

Quick Start

Open the systematic-debugging skill and follow Phase 1 to reproduce the issue, gather targeted evidence across layers, form a single hypothesis, test with the smallest change, and then implement the verified root-cause fix.

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 flaky tests instead of just fixing symptoms?

To find the root cause of flaky tests, follow a stepwise workflow: reproduce the issue consistently, gather evidence through instrumentation across component boundaries, form a single hypothesis, and test with the smallest change before implementing the fix.

What is the best way to debug production incidents systematically?

Systematic production incident debugging requires a four-phase process: root cause investigation, pattern analysis, hypothesis-driven minimal changes, and multi-layer validation. This disciplined approach prevents prolonged outages and avoids regressions caused by guesswork.

How do I trace errors across multi-component systems during integration failures?

Trace multi-component integration failures by adding diagnostics across component boundaries to collect evidence. Reproduce the issue consistently first, then use pattern analysis to isolate the root cause before modifying code.

Why do quick fixes and guesswork prolong software outages and introduce regressions?

Quick fixes and guesswork prolong outages because they hide true underlying causes rather than addressing them. A disciplined root-cause investigation process identifies the actual error source, preventing wasted time and new regressions.

Can I use hypothesis-driven testing to isolate build failures?

Yes, you can isolate build failures using hypothesis-driven testing. Create a failing reproduction, test one variable at a time with minimal changes, and verify the fix before proceeding to ensure you have found the actual root cause.

When should I add instrumentation during incident response?

Add instrumentation during incident response in the initial root cause investigation phase. Collect targeted evidence across layers before changing any code to ensure your hypothesis is based on observed data rather than assumptions.