systematic-debugging

Diagnose root causes of software bugs using a four-phase framework.

Updated Oct 22, 2025
One-click install
npx skills add https://github.com/franroa/chezmoi --skill systematic-debugging-franroa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/franroa/chezmoi/tree/main/dot_opencode/superpowers/skills/systematic-debugging
Command: npx skills add https://github.com/franroa/chezmoi --skill systematic-debugging-franroa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents wasted time and new bugs caused by random fixes or symptom-treating. It provides a structured, four-phase framework to ensure you always find the root cause of any issue before attempting solutions.

Core Features & Use Cases

  • Four-Phase Framework: Guides you through Root Cause Investigation, Pattern Analysis, Hypothesis Testing, and Implementation, ensuring thoroughness.
  • Anti-Rationalization: Explicitly counters common excuses for taking shortcuts, even under extreme pressure (e.g., "emergency, no time for process").
  • Evidence-Based Fixing: Mandates creating a failing test case and verifying fixes, preventing regressions.
  • Use Case: When any bug, test failure, or unexpected behavior occurs, use this Skill to systematically diagnose and fix the problem. For example, if a production API is down, this Skill will guide you to investigate the root cause rather than applying a quick, unverified patch.

Quick Start

Announce skill usage

I'm using the systematic-debugging skill to investigate this bug.

The skill will then guide you through the four-phase debugging process.

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 just fixing symptoms?

Root cause analysis requires a systematic four-phase framework: investigate what's happening, analyze patterns across failures, test hypotheses against evidence, then implement the fix. This Skill guides you through each phase to ensure you diagnose the actual problem, not just treat visible symptoms, preventing wasted time and new bugs from incorrect patches.

What's the best way to debug test failures and production bugs systematically?

Systematic debugging applies a structured process across test failures, production bugs, integration issues, and performance problems. It mandates diagnostic instrumentation, evidence-based verification through failing test cases, and explicit anti-patterns that resist shortcuts even under time pressure, ensuring thorough root-cause exploration before any fix.

How do I avoid applying quick fixes that create more problems?

Quick fixes often treat symptoms rather than root causes, introducing new bugs. This Skill enforces a four-phase framework with explicit rules against rationalization and shortcuts, requiring you to investigate thoroughly, test hypotheses with evidence, and verify fixes with failing test cases before deployment.

Can I use systematic debugging across different software stacks and architectures?

Yes. Systematic debugging applies to modern software stacks, multi-component architectures, test failures, integration issues, and performance problems. The framework adapts to different technologies by focusing on diagnostic instrumentation and evidence-based hypothesis testing rather than stack-specific tools.

Why does my bug fix work locally but fail in production?

Fixes that don't address root causes often fail in different contexts. Systematic debugging requires diagnostic instrumentation across your multi-component architecture, evidence-based verification through failing test cases, and hypothesis testing that ensures your fix works across environments, not just locally.

What do I do when there's no time to investigate thoroughly?

Time pressure is exactly when root-cause analysis matters most—quick patches create cascading failures. This Skill includes explicit anti-rationalization rules that counter excuses for shortcuts, showing why systematic debugging saves time overall by preventing regressions and follow-up firefighting.