debugging

Identify and document software failure root causes through structured investigation phases.

Updated Mar 18, 2026
One-click install
npx skills add https://github.com/djwmobley/pipeline --skill debugging-djwmobley
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: debugging
Source: https://github.com/djwmobley/pipeline/tree/main/skills/debugging
Command: npx skills add https://github.com/djwmobley/pipeline --skill debugging-djwmobley

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Random fixes waste time and create new bugs. This skill enforces a disciplined, phase-based approach to identify the true root cause of failures before attempting any changes, reducing regression risk and wasted effort.

Core Features & Use Cases

  • Phase-based investigation: Phase 1 collects error evidence, reproduces the issue, and traces data flow to locate root causes.
  • Pattern analysis: Phase 2 compares against references, identifies differences, and surfaces the highest-leverage hypotheses.
  • Hypothesis testing & implementation: Phase 3 selects a single, testable hypothesis and validates it with minimal changes; Phase 4 guides controlled implementation and verification.
  • Red flags & governance: Clear criteria to stop if architecture issues arise, ensuring disciplined problem-solving.

Quick Start

Start Phase 1 by reading error messages, reproducing the issue, and gathering evidence before proposing any fixes.

Frequently Asked Questions about debugging

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

FAQPage Schema
What is the best way to find the root cause of software failures in multi-component systems?▼

Root cause diagnosis for software failures is best achieved through a phase-based investigation that collects error evidence, reproduces the issue, and traces data flow before proposing fixes. This structured approach prevents wasted effort and reduces regression risk.

How do I systematically trace production bugs across different stacks?▼

Systematically trace production bugs by gathering error evidence in Phase 1, performing pattern analysis against references in Phase 2, and testing high-leverage hypotheses with minimal changes in Phase 3 before controlled implementation.

Why does fixing complex traces often create new bugs instead of solving the issue?▼

Fixing complex traces creates new bugs when changes are attempted before identifying the true root cause. A disciplined approach enforces data gathering and hypothesis testing prior to implementation, ensuring the actual failure mechanism is addressed.

When should I stop investigating an error and avoid applying a fix?▼

You should stop investigating and avoid applying a fix when clear red flag criteria indicate underlying architecture issues. Governance rules ensure disciplined problem-solving by halting changes if fundamental architectural problems surface during analysis.

How do I validate a hypothesis during software debugging?▼

Validate a debugging hypothesis by selecting a single, testable hypothesis in Phase 3 and applying minimal changes to confirm it. This controlled validation ensures fixes target the confirmed root cause without introducing widespread system alterations.

Can I use a structured debugging approach for any software stack or only specific environments?▼

A structured debugging approach applies to production bugs across multi-component systems and diverse stacks. It relies on universal phases of data gathering, pattern analysis, and controlled implementation rather than stack-specific tooling.