systematic-debugging

Diagnose software bugs through four investigative phases for root cause analysis.

Updated Jan 9, 2026
One-click install
npx skills add https://github.com/Draft-Official/draft-web --skill systematic-debugging-draft-official
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Draft-Official/draft-web/tree/main/.agents/superpowers/4.3.0/skills/systematic-debugging
Command: npx skills add https://github.com/Draft-Official/draft-web --skill systematic-debugging-draft-official

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and scripts (resource) components.

What problem does it solve?

It helps developers systematically identify and eliminate bugs by following a structured, four-phase process that prevents shortcut fixes and ensures long-term stability.

Core Features & Use Cases

  • Root Cause Analysis: Guides through detailed investigation steps for consistent reproduction and evidence collection.
  • Pattern Recognition: Assists in comparing current issues to reference solutions to identify key differences.
  • Hypothesis Testing: Encourages forming and validating specific hypotheses with minimal changes.
  • Implementation & Verification: Ensures fixes are based on verified root causes with proper testing procedures.
  • Use Case: When troubleshooting a flaky production bug, use this skill to trace the root, avoid patching symptoms, and reinforce the system’s reliability.

Quick Start

Load the debugging skill and follow the step-by-step instructions to investigate an issue thoroughly before attempting any fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is systematic debugging and when do I need it for software bugs?

Systematic debugging is a disciplined, four-phase investigative process for diagnosing and resolving software bugs. You need it when troubleshooting complex issues, such as flaky production bugs, to ensure root cause analysis rather than applying temporary patches.

How do I investigate a software bug to find the root cause?

To investigate a software bug, follow a structured process emphasizing consistent reproduction, evidence collection, pattern comparison against reference solutions, and hypothesis validation. This ensures you verify the root cause before attempting any system fixes.

What's the best way to stop applying quick patches when fixing code under pressure?

The best way to resist quick patches under pressure is using a structured debugging workflow with defined investigative phases. This framework enforces hypothesis testing and verified fixes, ensuring long-term systemic stability over temporary symptom patching.

How does hypothesis testing work during software investigation?

Hypothesis testing during software investigation involves forming specific hypotheses about the bug's root cause and validating them with minimal changes. This disciplined approach prevents shortcut fixes by requiring evidence before implementing the actual code correction.

Does this debugging workflow work for production issues or just local development?

This debugging workflow works for production issues, including flaky production bugs, as well as local development. The systematic framework emphasizes tracing root causes and reinforcing system reliability regardless of the environment's pressure or complexity.

When should I not use a systematic debugging approach?

You should not avoid systematic debugging even under stress, as skipping the disciplined workflow risks applying temporary patches. However, for trivial syntax errors with obvious causes, the full four-phase investigation may be unnecessary overhead.