systematic-debugging

Trace root causes of bugs through a four-phase debugging workflow.

1|Updated Feb 14, 2026
One-click install
npx skills add https://github.com/ynitto/sandbox --skill systematic-debugging-ynitto
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/ynitto/sandbox/tree/main/.github/skills/systematic-debugging
Command: npx skills add https://github.com/ynitto/sandbox --skill systematic-debugging-ynitto

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

Systematic debugging to identify root causes before patching, reducing wasted time and preventing recurring issues during debugging sessions.

Core Features & Use Cases

  • Phase-driven debugging workflow (root-cause investigation, pattern analysis, hypothesis testing, implementation) to fix bugs efficiently.
  • Multi-layer validation and built-in references to guide traceability across components.
  • Safe, incremental changes and robust verification to ensure fixes address the real problem.
  • Use Case: When tests fail or runtime bugs appear, apply this skill to trace to the root cause, propose a minimal fix, implement it, and validate with tests.

Quick Start

Describe the current bug, gather evidence across phases, and propose a root-cause fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I debug a flaky test by finding the root cause instead of just patching it?

Debug flaky tests by applying a four-phase systematic process: root-cause investigation, pattern analysis, hypothesis testing, and incremental implementation. This enforces multi-layer validation to ensure your fix addresses the actual problem, reducing wasted time and preventing recurring issues.

What is the best way to trace runtime bugs across multiple software components?

The best way to trace runtime bugs is using a phase-driven debugging workflow with built-in references for traceability across components. This method enforces multi-layer validation and incremental changes to robustly verify that fixes resolve the real problem.

How do I systematically fix a software bug without guessing?

Fix software bugs without guessing by following a disciplined four-phase workflow: investigate root causes, analyze patterns, test hypotheses, and implement minimal fixes. This systematic debugging approach enforces robust verification to eliminate patching guesswork.

Can I use this systematic debugging approach for any test failure in my software project?

Yes, this systematic debugging approach applies to test failures, flaky tests, and runtime bugs across any software project. It guides you to gather evidence across phases, propose a root-cause fix, implement it safely, and validate with tests.

Why does my bug fix keep recurring after I patch the code?

Bug fixes recur when you patch symptoms instead of identifying root causes. A systematic debugging workflow enforces root-cause investigation and multi-layer validation before implementation, ensuring fixes address the real problem and preventing recurring issues.

What are the limitations of systematic debugging for resolving software issues?

Systematic debugging requires disciplined adherence to a four-phase process, which may initially slow down patching. However, this structured investigation and hypothesis testing approach is necessary to reduce guesswork and ensure robust, long-term fixes across complex software projects.