systematic-debugging

Debug software bugs using a structured four-phase investigation and hypothesis testing workflow.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Structured four-phase debugging methodology to ensure root-cause identification before fixes, reducing guesswork and regressive patches.

Core Features & Use Cases

  • Four-Phase Workflow: Investigation, Analysis of Patterns, Hypothesis & Testing, and Implementation.
  • Evidence-Driven Debugging: Reproduces errors, traces data flow, and isolates scope with git diff/logs.
  • Guardrails and Documentation: Includes red flags and verification steps to prevent premature fixes and ensure traceability.
  • Use Case: When a runtime error or regression occurs, apply the process to locate the root cause, validate hypotheses, and implement minimal, verifiable changes.

Quick Start

Follow the four-phase workflow: investigate the error, analyze patterns, form a hypothesis, and implement a minimal fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I find the root cause of a runtime error instead of guessing?

Root-cause analysis for runtime errors requires a structured four-phase debugging approach: investigate the error, analyze patterns, test hypotheses, and implement minimal verifiable fixes. This methodology enforces error reproduction and evidence-based isolation before any code changes.

What is the best way to debug intermittent CI failures and build issues?

Debugging CI failures and build issues works best with systematic error reproduction and evidence-driven pattern analysis. By tracing data flow and isolating scope with git diff and logs, you identify the root cause before applying patches, preventing regressive fixes.

How do I systematically isolate unexpected behavior across multi-layer systems?

To isolate unexpected behavior across multi-layer systems, apply a structured debugging workflow that reproduces errors, traces data flow across layers, and tests hypotheses against evidence. This ensures you locate the exact root cause rather than patching symptoms.

Can I use a structured debugging process for failing tests and lints?

Yes, structured debugging applies to failing tests and lints. The four-phase methodology covers investigation, pattern analysis, hypothesis testing, and implementation, ensuring you verify the root cause of test or lint failures before applying minimal fixes.

Why do my bug fixes keep causing regressions in other parts of the system?

Regressive patches occur when fixes target symptoms instead of root causes. Using hypothesis testing and minimal verifiable implementations within a structured debugging workflow prevents guesswork and ensures changes are isolated and fully verified.

What are the limitations of systematic debugging for urgent production incidents?

Systematic debugging enforces rigorous error reproduction and hypothesis testing, which requires time for evidence gathering. For urgent incidents, the structured four-phase process ensures accuracy but may slow down immediate mitigation compared to hot patching.