systematic-debugging

Enforce a four-phase root-cause debugging workflow for software engineering issues.

2|Updated Mar 2, 2026
One-click install
npx skills add https://github.com/tizee/skills --skill systematic-debugging-tizee
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/tizee/skills/tree/main/superpowers-skills/systematic-debugging
Command: npx skills add https://github.com/tizee/skills --skill systematic-debugging-tizee

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Tackling bugs and failures by enforcing a four-phase, root-cause workflow to prevent symptom fixes and rushed decisions.

Core Features & Use Cases

  • Four mandatory phases: Root Cause Investigation, Pattern Analysis, Hypothesis and Testing, and Implementation.
  • Anti-patterns and defensive practices (defense-in-depth, stack tracing) to ensure robust fixes.
  • Real-world testing guidance, documentation of decisions, and escalation when no root cause is found.

Quick Start

Load the skill and follow Phase 1 through Phase 4 to identify and fix the root cause before attempting changes.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is systematic root-cause debugging and when do I need it?

Systematic root-cause debugging is a structured workflow that enforces evidence gathering, pattern analysis, and hypothesis testing. You need it for production incidents, flaky tests, and deep stack traces to prevent chaotic symptom fixes and rushed decisions.

How do I debug a production incident without just fixing the symptom?

Debug a production incident by following a four-phase root-cause workflow: gather evidence, analyze patterns, test hypotheses, and implement fixes. This structured approach ensures you resolve the underlying failure rather than merely patching the visible symptom.

What is the best way to trace deep stack errors and prevent regressions?

The best way to trace deep stack errors is applying a four-phase debugging process with defense-in-depth practices. Tracing the root cause before implementation and adding defensive layers prevents future regressions and ensures robust software fixes.

Can I use a structured debugging workflow for flaky tests?

Yes, you can use this structured debugging workflow for flaky tests. It applies evidence gathering and pattern analysis to identify the root cause of intermittent failures, ensuring your hypothesis testing proves the fix before implementation.

What should I do if I cannot find the root cause during incident response?

If you cannot find the root cause during incident response, the debugging workflow includes an escalation phase. You must document your gathered evidence, pattern analysis, and tested hypotheses to support further investigation and prevent rushed decisions.