systematic-debugging

Guide teams through four debugging phases to identify root causes before fixes.

1|Updated Sep 11, 2023

Search Tags:#debugging #defense-in-depth #systematic #phases #root-cause #root-cause-tracing

Ready to run

npx skills add https://github.com/vcntttt/dotfiles --skill systematic-debugging-vcntttt

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/vcntttt/dotfiles/tree/main/.agents/skills/systematic-debugging
Command: npx skills add https://github.com/vcntttt/dotfiles --skill systematic-debugging-vcntttt

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides a structured, four-phase approach to debugging that ensures you identify the root cause before proposing fixes, reducing wasted time during incidents and under deadlines.

Core Features & Use Cases

Four-phase framework: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, and Implementation.
Anti-shortcuts and explicit failure modes to resist quick-fix temptations.
Defense-in-depth guidance with layered checks and contextual validation.
Applicable to in-flight debugging, code reviews, production incidents, flaky tests, and integration issues.

Quick Start

Load the skill, read the overview, then complete Phase 1 before proposing fixes. If you are tempted to skip, review the anti-patterns and run through the Phase 1 checklist to ensure root cause is identified.

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 fixes during production incidents?▼

Root-cause debugging is a structured approach that identifies the actual origin of bugs before implementing fixes. It prevents symptom fixes by requiring teams to complete all four investigation phases, ensuring underlying issues are resolved rather than just treating visible errors.

How do I systematically debug flaky tests and integration issues under deadline pressure?▼

To debug flaky tests and integration issues systematically, follow the four-phase framework: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, and Implementation. Complete Phase 1 fully before proposing fixes to avoid wasted time and quick-fix temptations under pressure.

Does systematic debugging work for code reviews and production incidents, or is it only for active development?▼

Systematic debugging works across development, testing, production incidents, code reviews, and integration scenarios. Its four-phase framework and defense-in-depth guidance apply to any context where identifying root causes before fixing is critical to avoid patching symptoms.

What's the best way to stop developers from taking debugging shortcuts when resolving urgent bugs?▼

The best way to stop debugging shortcuts is using explicit anti-shortcut failure modes and a mandatory Phase 1 checklist. By enforcing defense-in-depth with layered checks and contextual validation, the framework resists quick-fix temptations during high-pressure incident resolution.

Why does my bug fix keep reintroducing the same issue in different forms across the system?▼

Your bug fix likely addresses symptoms rather than the root cause because investigation phases were skipped. Applying systematic root-cause tracing with pattern analysis and defense-in-depth layered checks ensures the underlying failure mode is fully resolved before implementation.

When should I not use a systematic debugging approach for resolving software defects?▼

You should not skip systematic debugging when dealing with complex production incidents, flaky tests, or integration issues, as bypassing root-cause investigation leads to symptom fixes. However, for trivial, single-line syntax errors with obvious causes, the full four-phase framework may be unnecessary overhead.