systematic-debugging

Enforce a four-phase root-cause investigation process for debugging issues.

27|9|Updated Feb 3, 2026
One-click install
npx skills add https://github.com/datasciencemonkey/claude-code-cli-bricks --skill systematic-debugging-datasciencemonkey
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/datasciencemonkey/claude-code-cli-bricks/tree/main/.claude/skills/systematic-debugging
Command: npx skills add https://github.com/datasciencemonkey/claude-code-cli-bricks --skill systematic-debugging-datasciencemonkey

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured, repeatable approach to debugging that emphasizes root-cause investigation before proposing fixes. It helps teams avoid symptom-only patches, reduces iteration time, and raises the probability of durable resolutions.

Core Features & Use Cases

  • Four-phase method: Phase 1 (Root Cause Investigation) → Phase 2 (Pattern Analysis) → Phase 3 (Hypothesis & Testing) → Phase 4 (Implementation).
  • Defense-in-depth mindset: Encourages validation at multiple layers to make bugs structurally impossible.
  • Linkable references: Supports tracing root causes with forward/backward tracing techniques and diagnostic instrumentation.
  • Use Cases: Ideal for flaky tests, production incidents, elusive bugs, and scenarios where time pressure tempts quick fixes.

Quick Start

  1. Load the skill: skills/debugging/systematic-debugging
  2. Read the overview and follow Phase 1–4 checklists before proposing any fixes
  3. If you encounter a data-flow or root-cause issue, consult supporting techniques: root-cause-tracing.md, defense-in-depth.md, and condition-based-waiting.md

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is a systematic debugging framework for finding root causes?

Systematic debugging is a structured, repeatable approach enforcing a four-phase root-cause investigation process before fixes. It helps avoid symptom-only patches, reduces iteration time, and raises the probability of durable resolutions across code, tests, and production issues.

How do I debug flaky tests and production incidents step by step?

Debug flaky tests and production incidents by following a four-phase method: Phase 1 covers root cause investigation, Phase 2 involves pattern analysis, Phase 3 focuses on hypothesis and testing, and Phase 4 handles implementation with defense-in-depth validation to prevent regression.

What is the best way to stop recurring bugs and prevent regression?

The best way to prevent regression is applying a defense-in-depth mindset during debugging, encouraging validation at multiple layers to make bugs structurally impossible. Complete all investigation phases before fixes and leverage supporting techniques to ensure durable resolutions.

How does root-cause tracing work when investigating elusive bugs?

Root-cause tracing works by using forward and backward tracing techniques alongside diagnostic instrumentation. It supports the investigation process by linking references and tracing data-flow issues to pinpoint the actual origin of elusive bugs rather than patching symptoms.

Can I use this systematic debugging method for urgent time-pressure scenarios?

Yes, this debugging method is ideal for urgent scenarios where time pressure tempts quick fixes. It provides a structured checklist across four phases to ensure practitioners complete thorough root-cause investigation before proposing fixes, avoiding symptom-only patches under stress.