systematic-debugging

Perform structured root-cause analysis with a four-phase debugging workflow.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/mferris77/SpringBoard --skill systematic-debugging-mferris77
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/mferris77/SpringBoard/tree/main/vscode-citadel-harness/skills/systematic-debugging
Command: npx skills add https://github.com/mferris77/SpringBoard --skill systematic-debugging-mferris77

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

4-phase root cause analysis: observe, hypothesize, verify, fix. Enforces investigation before any code changes. Emergency stop after 2 failed fixes. Prevents shotgun debugging and fix cascades.

Core Features & Use Cases

  • Structured four-phase debugging workflow: observe → hypothesize → verify → fix.
  • Emergency stop after two failed fixes to prevent cascading changes.
  • Auditable, repeatable process for safe, high-quality software debugging.

Quick Start

Describe the issue you want to investigate and let systematic-debugging guide you through the four phases (observe, hypothesize, verify, 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 prevent fix cascades?

Root-cause debugging is a structured workflow that enforces investigation before any code changes. It prevents fix cascades by requiring hypothesis verification and triggering an emergency stop after two failed fixes.

How do I systematically debug runtime errors and behavior discrepancies?

To systematically debug runtime errors and behavior discrepancies, follow a four-phase workflow: observe the issue, hypothesize the root cause, verify the hypothesis, and then apply the fix.

How can I stop shotgun debugging when resolving type errors across my codebase?

You can stop shotgun debugging by enforcing an auditable process that requires explicit hypothesis verification steps before applying code changes, ensuring safe and repeatable software debugging.

Does this debugging process include any safeguards for repeated failures?

Yes, the debugging process includes an emergency stop rule that halts changes after two failed fixes, preventing cascading changes and further codebase destabilization.

What is the best way to ensure my software debugging process is auditable?

The best way to ensure an auditable software debugging process is to follow a structured four-phase workflow with explicit hypothesis verification steps before applying any code modifications.

When should I use a structured root-cause analysis workflow for software engineering?

Use a structured root-cause analysis workflow for software engineering tasks like runtime errors, type errors, and behavior discrepancies to ensure safe, high-quality debugging instead of unstructured trial and error.