systematic-debugging

Diagnose software bugs through a four-phase root-cause investigation process.

4|1|Updated Jun 7, 2025
One-click install
npx skills add https://github.com/alexanderop/MarkVim --skill systematic-debugging-alexanderop
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/alexanderop/MarkVim/tree/main/.claude/skills/debugger
Command: npx skills add https://github.com/alexanderop/MarkVim --skill systematic-debugging-alexanderop

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a rigorous, four-phase framework to systematically identify the root cause of any technical issue, preventing wasted time on random fixes and the introduction of new bugs. It ensures you understand why a problem occurs before attempting how to fix it.

Core Features & Use Cases

  • Root Cause Investigation: Guides through careful error message analysis, consistent reproduction, and evidence gathering in multi-component systems.
  • Pattern Analysis: Helps identify differences between working and broken examples, and understand dependencies.
  • Hypothesis Testing: Enforces a scientific method for proposing and minimally testing single hypotheses.
  • Architectural Review: Triggers a critical re-evaluation of architecture if multiple fixes fail, preventing symptom-chasing.
  • Use Case: When a critical production bug appears, activate this skill to methodically trace the issue, gather evidence, and formulate a precise fix, avoiding panic and ensuring a lasting solution.

Quick Start

I'm encountering an intermittent test failure in our CI pipeline. Use the systematic-debugging skill to help me find the root cause.

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 bug instead of applying random fixes?

Root cause debugging involves systematically investigating error messages, reproducing the issue consistently, and gathering evidence before proposing fixes. This four-phase approach—root cause investigation, pattern analysis, hypothesis testing, and implementation—ensures you understand *why* a problem occurs, preventing wasted effort and new bugs from symptom-chasing.

What's the best way to troubleshoot intermittent test failures or production bugs?

Apply a scientific method: collect detailed data about when the failure occurs, identify differences between working and broken states, test single hypotheses with minimal changes, and validate each fix with evidence. This systematic troubleshooting prevents panic-driven fixes and ensures solutions address the actual problem, not just symptoms.

How do I know when to stop fixing symptoms and reconsider my architecture?

If multiple fixes fail to resolve the issue, the framework triggers an architectural review to evaluate whether the root cause lies in design rather than implementation. This prevents endless debugging cycles and identifies when a deeper structural change is needed.

Can I use systematic debugging for different types of failures—performance issues, build failures, and integration problems?

Yes. The four-phase framework applies across test failures, production bugs, unexpected behavior, performance problems, build failures, and integration issues. The same evidence-based investigation and hypothesis-testing process works regardless of failure type.

What data do I need to collect before proposing a bug fix?

Reproducibility and evidence are mandatory: document exact error messages, conditions that trigger the failure, differences between working and broken states, and dependencies involved. This data collection ensures your hypothesis is testable and prevents fixes based on incomplete information.