systematic-debugging

Enforce a four-phase root-cause investigation framework before applying any fix.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/chriscarterux/chris-claude-stack --skill systematic-debugging
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/chriscarterux/chris-claude-stack/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/chriscarterux/chris-claude-stack --skill systematic-debugging

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the frustration and wasted time of "guess-and-check" debugging. It provides a rigorous, four-phase framework to systematically identify the root cause of any bug or unexpected behavior, ensuring fixes are permanent, don't introduce new problems, and save significant development time.

Core Features & Use Cases

  • Root Cause Investigation: Mandates careful error message analysis, consistent reproduction, and evidence gathering across multi-component systems before any fixes are attempted.
  • Pattern Analysis: Guides you to compare broken code with working examples, identify differences, and understand dependencies to pinpoint the exact issue.
  • Hypothesis-Driven Testing: Formulate a single, testable hypothesis and make the smallest possible change to validate it, preventing shotgun debugging and ensuring clarity.
  • Use Case: A critical production API is down with a "Connection timeout" error. Instead of immediately adding a retry, use this skill to investigate recent changes, gather diagnostic logs across all components, and trace the data flow to find the exact point of failure and its underlying cause.

Quick Start

Phase 1: Root Cause Investigation - BEFORE ATTEMPTING ANY FIX

  1. Read Error Messages Carefully
  2. Reproduce Consistently
  3. Check Recent Changes
  4. Gather Evidence in Multi-Component Systems
  5. Trace Data Flow

Only after completing Phase 1, proceed to Phase 2.

Frequently Asked Questions about systematic-debugging

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

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

Systematic debugging enforces a four-phase framework that mandates root-cause investigation before any fix. Start by reading error messages carefully, reproducing the issue consistently, checking recent changes, gathering evidence across components, and tracing data flow. Only after completing Phase 1 investigation do you proceed to fixes, ensuring solutions are permanent and don't introduce new problems.

What's the best way to find the root cause of a production bug?

Root-cause investigation requires careful analysis of error messages, consistent reproduction of the failure, review of recent code changes, and evidence collection across all system components. Trace the data flow to pinpoint the exact failure point and its underlying cause rather than applying quick fixes that mask symptoms.

How do I avoid guess-and-check debugging and shotgun fixes?

Formulate a single, testable hypothesis and make the smallest possible change to validate it. This hypothesis-driven testing approach replaces shotgun debugging by enforcing evidence-based investigation first. Compare broken code with working examples to identify differences and understand dependencies before attempting any fix.

Can I use this debugging approach for test failures and performance problems?

Yes. The four-phase framework applies to any technical issue—test failures, production bugs, performance problems, builds, and integrations. It's especially effective under time pressure when quick fixes seem tempting, ensuring thorough investigation yields durable solutions across all failure types.

Why should I investigate before fixing a bug?

Investigation before fixes prevents wasted time on guess-and-check debugging and ensures solutions address root causes, not symptoms. Thorough investigation eliminates recurring bugs, prevents new problems from incomplete fixes, and saves significant development time through permanent, durable solutions.