systematic-debugging

Trace software issues to root causes using a four-phase debugging process.

5|Updated Mar 16, 2019
One-click install
npx skills add https://github.com/third774/dotfiles --skill systematic-debugging-third774
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/third774/dotfiles/tree/main/opencode/skill/systematic-debugging
Command: npx skills add https://github.com/third774/dotfiles --skill systematic-debugging-third774

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a disciplined, four-phase debugging framework to trace issues to their root causes rather than patching symptoms.

Core Features & Use Cases

  • Four-Phase Process: Phase 1 Observe, Phase 2 Hypothesize, Phase 3 Isolate, Phase 4 Verify.
  • Evidence-driven: Check error messages, reproducibility, and boundary data flows.
  • Defensive Debugging: Adds instrumentation and validation at each layer.

Quick Start

Use the four-phase checklist to guide debugging sessions and ensure root-cause resolution.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I systematically debug software issues instead of just patching symptoms?

Systematic debugging traces root causes through four phases: observe the issue and gather evidence, hypothesize potential causes, isolate the actual source through testing, and verify the fix resolves the root problem. This prevents temporary patches and ensures lasting solutions.

What's the best way to debug production anomalies and performance problems?

Apply a disciplined four-phase process with explicit checklists and diagnostic instrumentation. Collect trace data across all layers, validate boundary data flows, and enforce evidence-based decision-making before implementing any fix.

How do I debug multi-component systems and integration issues?

Use the four-phase framework to systematically investigate across components: observe where failures occur, hypothesize interaction points, isolate the failing boundary or layer with instrumentation, and verify the root cause before proposing fixes.

Can I use this debugging approach for build failures and test failures?

Yes. The four-phase debugging process applies to build errors, test failures, and any software issue. Follow the same phases—observe error messages and reproducibility, hypothesize root causes, isolate the source through diagnostic validation, and verify before fixing.

What's the difference between root-cause debugging and defensive debugging?

Root-cause debugging identifies why a problem occurred; defensive debugging adds instrumentation and validation at each layer to catch issues early. This framework combines both: it traces the root cause while building in checks that prevent similar issues.

When should I use a four-phase debugging process instead of fixing errors immediately?

Use this framework especially in high-pressure scenarios, when issues affect multiple components, or when quick fixes keep failing. It prevents wasted time on symptoms and ensures fixes actually resolve the underlying problem.