superpower-debugging

Trace bugs to root causes using a four-phase debugging workflow.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic Debugging provides a disciplined, four-phase approach to diagnosing bugs under time pressure, ensuring root causes are identified before proposing fixes.

Core Features & Use Cases

  • Phase-driven workflow: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, and Implementation.
  • Guardrails that prevent premature fixes and help resist rationalization under pressure.
  • Guidance for critical scenarios like production incidents, flaky tests, and complex multi-component systems.

Quick Start

Follow the four-phase process starting with Phase 1: Root Cause Investigation to trace issues to their source.

Frequently Asked Questions about superpower-debugging

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

FAQPage Schema
What is systematic debugging and how does it help find root causes?

Systematic debugging is a disciplined, four-phase approach that traces bugs from symptom to root cause before implementing fixes. It prevents premature patching by enforcing a structured investigation, ensuring you resolve the actual underlying issue rather than just the visible symptom.

How do I debug flaky tests or production incidents without guessing?

You can debug flaky tests or production incidents by applying a structured workflow that separates root cause investigation from implementation. This method provides specific guidance for critical scenarios, helping you analyze patterns and test hypotheses methodically under pressure instead of guessing.

How do I stop myself from applying premature fixes when debugging under time pressure?

To stop applying premature fixes, use a debugging workflow with built-in guardrails that enforce root cause investigation before implementation. These guardrails help resist rationalization and ensure you test hypotheses thoroughly before modifying code.

Can I use this debugging method for unexpected behavior across any codebase?

Yes, you can use this method to trace bugs, test failures, or unexpected behavior across any codebase. The workflow is applicable to complex multi-component systems and enforces adding defensive checks to prevent future regression.

What is the best way to trace a bug from a symptom to its root cause?

The best way to trace a bug to its root cause is following a four-phase workflow: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, and Implementation. This process ensures you systematically identify the source before writing a fix.