systematic-debugging

Enforce a four-phase root-cause debugging process before applying fixes.

Updated May 15, 2026
One-click install
npx skills add https://github.com/nachopalmeri/agents-system --skill systematic-debugging-nachopalmeri
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/nachopalmeri/agents-system/tree/main/.agents/skills/systematic-debugging
Command: npx skills add https://github.com/nachopalmeri/agents-system --skill systematic-debugging-nachopalmeri

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic-debugging provides a disciplined, four-phase approach to debugging to ensure root-cause investigation before fixes.

Core Features & Use Cases

  • Phase-based workflow: Root Cause Investigation, Pattern Analysis, Hypothesis & Testing, Implementation.
  • Anti-shortcut enforcement: STOP and re-analyze; NEVER fix the symptom.
  • Defense-in-depth guidance with multi-layer validation and stack-trace instrumentation.
  • Real-world testing framework ties to related resources (root-cause-tracing.md, defense-in-depth.md, condition-based-waiting.md, etc.)
  • Ready-to-use templates for testing approaches and iteration strategies.

Quick Start

Load the skill and begin Phase 1 to start tracing the root cause before attempting any fix.

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 why should I investigate before fixing?

Root-cause debugging identifies the actual source of a technical issue rather than treating symptoms. It enforces a disciplined investigation process to prevent recurring faults across code, tests, and systems, ensuring the underlying problem is eliminated safely.

How do I find the root cause of a system failure instead of patching symptoms?

To find the root cause of a system failure, apply a four-phase debugging workflow: investigate the root cause, analyze patterns, test hypotheses, and implement the fix. Anti-shortcut enforcement stops you from patching symptoms, ensuring true resolution.

What is the best way to debug complex technical issues across multiple system layers?

The best way to debug complex issues is using defense-in-depth validation with stack-trace instrumentation. This approach applies multi-layer testing and hypothesis verification across code and systems to pinpoint failures accurately before implementation.

How do I test debugging hypotheses safely before applying a code fix?

Test debugging hypotheses safely by following a structured workflow that isolates the failure through pattern analysis and stack-trace instrumentation. This validates your assumptions across multiple layers before any actual code implementation begins.

Does this root-cause debugging workflow work for both code and infrastructure testing?

Yes, this root-cause debugging workflow applies to technical issues across code, tests, and systems. It provides a generalized four-phase investigation and validation framework that guides developers through diverse debugging scenarios.