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.