systematic-debugging

Identify root causes of software bugs through a four-phase debugging process.

Updated Aug 20, 2022
One-click install
npx skills add https://github.com/Neroro64/dotfiles --skill systematic-debugging-neroro64
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Neroro64/dotfiles/tree/main/configs/omp/agent/skills/systematic-debugging
Command: npx skills add https://github.com/Neroro64/dotfiles --skill systematic-debugging-neroro64

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic Debugging provides a disciplined process to uncover root causes of bugs and resist symptom-focused fixes.

Core Features & Use Cases

  • Phase-driven workflow with four stages: Root Cause Investigation, Pattern Analysis, Hypothesis and Testing, and Implementation.
  • Guardrails and bulletproofing, including NEVER fix without root cause, anti-patterns, and defense-in-depth practices.
  • Suitable for production incidents, flaky tests, complex multi-component systems, and cross-team debugging.

Quick Start

Begin Phase 1 immediately by reading error messages, reproducing the issue, and gathering evidence to map the data flow.

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 a software bug instead of just fixing the symptom?

Root-cause debugging identifies the actual source of software bugs and prevents symptom-focused fixes. It enforces a disciplined four-phase process including Root Cause Investigation, Pattern Analysis, Hypothesis Testing, and Implementation to resolve issues permanently.

How do I debug a production incident across complex multi-component systems?

Debugging a production incident across multi-component systems requires mapping data flow by reading error messages and reproducing the issue. This systematic approach gathers evidence across single or multi-component architectures to pinpoint integration failures.

Can I use a systematic debugging process for flaky tests and integration issues?

Yes, systematic debugging applies directly to flaky tests and integration issues. It uses pattern analysis and hypothesis testing to trace intermittent test failures and cross-team integration problems back to their underlying root causes.

What are the limitations of symptom-focused fixes when resolving software bugs?

Symptom-focused fixes fail to resolve underlying software bugs and often cause regressions. A systematic process avoids this limitation by enforcing defense-in-depth practices and anti-pattern guardrails, ensuring you never implement fixes without finding the root cause.

How do I start the first phase of systematic debugging?

To start Phase 1 of systematic debugging, immediately read error messages, reproduce the issue, and gather evidence to map the data flow. This establishes the foundational Root Cause Investigation needed before analyzing patterns.