systematic-debugging

Trace root causes through a four-phase debugging workflow.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic Debugging provides a disciplined, four-phase approach that ensures root-cause investigation before proposing fixes, eliminating symptom-driven work and reducing rework.

Core Features & Use Cases

  • Phase-driven workflow: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, and Implementation, with explicit stop rules to prevent shortcut fixes.
  • Guardrails and anti-patterns: Never fix symptoms, STOP and re-analyze, and defense-in-depth policies that add validation at multiple layers.
  • Real-world use: Debugging complex, multi-component systems where issues surface deep in the stack.

Quick Start

Follow Phase 1: Root Cause Investigation to reproduce and trace the problem before attempting any fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I find the root cause of a bug instead of just fixing symptoms?

Root-cause debugging requires a disciplined four-phase process: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, and Implementation. This systematic approach traces issues deep in the call stack before applying fixes, eliminating symptom-driven work and reducing rework.

What is the best way to debug complex multi-component systems?

Debugging multi-component systems works best with a phase-driven workflow that enforces explicit stop rules. By reproducing and tracing the problem during Root Cause Investigation before attempting any fix, you prevent shortcut fixes across deep call stacks.

How do I stop guessing when debugging software issues?

To stop guessing during debugging, follow a systematic process with strict guardrails like NEVER fix the symptom and STOP and re-analyze. This forces thorough pattern analysis and hypothesis testing before implementation, replacing guesswork with structured investigation.

Does systematic debugging work for issues deep in the call stack?

Systematic debugging is specifically applicable across software projects and multi-component systems where issues appear deep in the call stack. Its four-phase approach with defense-in-depth policies adds validation at multiple layers to trace and resolve deep-stack problems.

When should I STOP and re-analyze during a debugging workflow?

You should STOP and re-analyze whenever you find yourself attempting a shortcut fix or treating a symptom. This guardrail enforces a return to root cause investigation, ensuring your hypothesis testing phase validates the actual underlying problem before implementation.

What are the limitations of symptom-driven debugging?

Symptom-driven debugging leads to rework because it bypasses root cause investigation, pattern analysis, and hypothesis testing. Without a disciplined four-phase process with guardrails, fixes fail to address issues deep in the call stack, causing recurring problems in multi-component systems.