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.