systematic-debugging

Guides root-cause investigations through a disciplined four-phase debugging workflow.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic Debugging eliminates guesswork when diagnosing software failures by forcing a disciplined, evidence-first approach that prevents symptom-only fixes and repeated regressions. It helps engineers avoid time-wasting shotgun fixes and makes debugging faster and more reliable under both calm and high-pressure conditions.

Core Features & Use Cases

  • Four-phase workflow: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, Implementation with failing tests.
  • Multi-component tracing & instrumentation: Practical guidance for adding diagnostics across component boundaries to locate the failing layer.
  • Pressure-resistant rules: Explicit anti-patterns and stop-gates ("ALWAYS", "NEVER", single-hypothesis rule) to avoid shortcuts during emergencies.
  • Supporting techniques: Defense-in-depth validation, condition-based waiting, root-cause tracing, and a small bisection shell helper for test pollution detection.
  • Use Case: Reproduce a flaky CI failure, trace the bad value to its origin, form a minimal hypothesis, add a failing test, and implement a single verified fix.

Quick Start

Use systematic-debugging to run the four-phase process: reproduce the issue, gather evidence across components, form a single hypothesis and test it minimally, then create a failing test and implement the root-cause fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is the best way to find the root cause of flaky tests in CI pipelines?

To debug unexpected system behavior systematically, reproduce the issue and gather evidence across component boundaries. Then analyze patterns, form a single hypothesis, test it minimally, and implement a root-cause fix driven by a failing test with defense-in-depth guards.

How do I reproduce and trace a software bug across multiple components?

During high-pressure production incidents, systematic debugging enforces pressure-resistant rules like the single-hypothesis rule and explicit stop-gates. These prevent shotgun fixes by requiring evidence-first pattern analysis and minimal hypothesis testing before implementing any root-cause fix.

How do I stop making symptom-only fixes and prevent repeated regressions?

Stop making symptom-only fixes by enforcing a disciplined four-phase workflow: root cause investigation, pattern analysis, single-hypothesis testing, and implementation with failing tests. This evidence-first approach eliminates guesswork and ensures defense-in-depth validation to prevent regressions.

Does systematic debugging work for production incidents and high-pressure emergencies?

Yes, systematic debugging is applicable to production incidents and enforces pressure-resistant rules with explicit anti-patterns and stop-gates. It ensures disciplined evidence collection, single-hypothesis testing, and root-cause tracing to avoid shortcuts during emergencies.