systematic-debugging

Enforce a four-phase observe, hypothesize, verify, and fix debugging workflow.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Root-cause debugging replaces guesswork with a structured four-phase workflow: observe, hypothesize, verify, and fix.

Core Features & Use Cases

  • Four-phase process to guide debugging from observation to fix.
  • Clear responsibilities for each phase: observe, hypothesize, verify, and implement.
  • Use cases include diagnosing complex bugs in codebases, ensuring evidence-based fixes, and preventing regressions.

Quick Start

Observe the issue, hypothesize causes, verify with evidence, and implement a root-cause fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is root-cause debugging and how does it stop guesswork?

A four-phase debugging workflow replaces guesswork by enforcing evidence collection, reproducible verification, and documented handoffs. It assigns clear responsibilities to observers, hypothesizers, verifiers, and fixers, ensuring verifiable code changes across diverse codebases and environments.

How do I debug complex bugs using a four-phase workflow?

To debug complex bugs, follow the four-phase workflow: observe the issue to collect evidence, hypothesize potential root causes, verify those hypotheses with reproducible tests, and implement a root-cause fix. This structured process ensures evidence-based fixes and prevents regressions.

How do I ensure reproducible verification when fixing code?

Reproducible verification is ensured by enforcing a structured procedure where hypothesized root causes are tested against collected evidence before any fix is implemented. This workflow mandates documented handoffs and consistent verification steps to guarantee verifiable code changes.

Does structured root-cause analysis work across diverse codebases and environments?

Yes, structured root-cause analysis is applicable to software debugging across diverse codebases and environments. It provides a consistent four-phase process—observe, hypothesize, verify, and fix—that guides teams through evidence collection and reproducible verification regardless of the specific technology stack.

Why should I use a structured debugging workflow instead of ad-hoc troubleshooting?

A structured debugging workflow replaces guesswork with evidence-driven analysis, ensuring that code changes are verifiable and regressions are prevented. By enforcing clear responsibilities and documented handoffs across four phases, it diagnoses complex bugs more reliably than ad-hoc troubleshooting.

When should I use evidence-driven debugging over other approaches?

Evidence-driven debugging should be used when diagnosing complex bugs in codebases where preventing regressions is critical. It enforces evidence collection and reproducible verification through a four-phase workflow, ensuring fixes address the actual root cause rather than symptoms.