skills.rest
steven-3
steven-3COMMUNITY
Explore all skills by this author →
GitHub

systematic-debugging

Enforce a four-phase root-cause debugging workflow with reproduction, isolation, minimal fixes, and test validation.

Updated Mar 17, 2026
Search Tags:#testing#debugging#bug fixing#verification#software reliability#root-cause analysis#fault isolation
One-click install
npx skills add https://github.com/steven-3/supermind --skill systematic-debugging-steven-3
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/steven-3/supermind/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/steven-3/supermind --skill systematic-debugging-steven-3

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging prevents wasted effort by stopping symptom-chasing and forcing a disciplined process to identify and fix the true root cause of a bug.

Core Features & Use Cases

  • Four-phase root-cause workflow: reproduce reliably, isolate the failing location via evidence, fix the underlying cause with minimal changes, then verify with targeted and broader checks.
  • Debugging discipline guardrails: forbids skipping phases, adding fixes before proving the failure, or relying on “probably” reasoning without reproduction and evidence.
  • Executor-ready for bug fixing: guides the fix-bug executor to produce fixes backed by a failing-then-passing test and verification against related code paths.

Quick Start

Use systematic-debugging when you see a failing behavior and need an evidence-based plan to reproduce, isolate, fix, and verify the underlying root cause.

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 symptom-chasing?▼

Root-cause debugging replaces symptom-chasing with a four-phase workflow: reproduce reliably, isolate the failing location via evidence, fix the underlying cause, and verify. This disciplined process ensures bug fixing targets the actual failure rather than superficial symptoms.

How do I isolate a software bug using data-flow tracing?▼

To isolate a bug using data-flow tracing, systematically trace data through the code path and apply binary-search elimination to pinpoint the exact failing location. This evidence-backed isolation phase prevents guessing and ensures accurate fault isolation before fixing.

Can I fix a reproducible failure without writing a failing test first?▼

No, systematic debugging forbids adding fixes before proving the failure. You must reliably reproduce the reproducible failure, isolate the exact failing code path, and validate proof-of-fix through a test that fails before the change and passes after.

What is the best way to debug software without guessing?▼

The best way to debug without guessing is enforcing a four-phase root-cause debugging workflow: reproduce reliably, isolate via evidence, fix with minimal changes, and verify. This approach replaces 'probably' reasoning with data-flow tracing and binary-search elimination for fault isolation.

Why does my bug fix keep breaking other related code paths?▼

Bug fixes break related code paths when skipping the verification phase. Systematic debugging requires proof-of-fix through a test that fails before and passes after the change, plus validation across the full test suite and related paths to ensure overall software reliability.

Related Skills

Explore More Software Engineering Skills→
derHakenderHaken
437

systematic-debugging

Trace data flow and apply a four-phase process to fix root causes.

Community
Advanced
dmae97dmae97
130

omk-flow-bugfix

Guide bug resolution from reproduction evidence to root-cause analysis and minimal code changes.

Community
Intermediate
webdevtodayjasonwebdevtodayjason
7

debugging-methodology

Diagnose software bugs using hypothesis-driven scientific debugging methodology.

Community
Advanced
romiluz13romiluz13
161

test-driven-development

Enforce the red-green-refactor TDD cycle with failing tests before production code.

Community
Intermediate