Performing Systematic Debugging for Stubborn Problems

Apply a modified Fagan Inspection methodology to debug stubborn system issues.

155|25|Updated Apr 27, 2025
One-click install
npx skills add https://github.com/sammcj/agentic-coding --skill performing-systematic-debugging-for-stubborn-problems
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Performing Systematic Debugging for Stubborn Problems
Source: https://github.com/sammcj/agentic-coding/tree/main/Claude/skills/systematic-debugging
Command: npx skills add https://github.com/sammcj/agentic-coding --skill performing-systematic-debugging-for-stubborn-problems

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses persistent and complex bugs that have resisted multiple previous fix attempts. It provides a structured, methodical approach to root cause analysis, preventing wasted time on trial-and-error debugging and ensuring a thorough resolution for intricate system issues.

Core Features & Use Cases

  • Modified Fagan Inspection: Applies a rigorous, four-phase inspection process (Overview, Systematic Inspection, Root Cause Analysis, Solution & Verification) to uncover hidden defects.
  • Five Whys Technique: Guides deep root cause analysis to identify fundamental issues, not just symptoms.
  • Structured Problem Solving: Ensures a comprehensive understanding of the problem, systematic defect identification, and a clear, verifiable solution plan.
  • Use Case: When a critical production bug is causing repeated failures and quick fixes have failed, use this Skill to perform a deep, structured investigation to prevent recurrence and stabilize the system.

Quick Start

To activate this Skill, simply state your persistent debugging problem: "I've been trying to fix this bug for days, and nothing is working. It involves complex interactions between the authentication service and the database. Can you help me perform a systematic debugging process?"

Frequently Asked Questions about Performing Systematic Debugging for Stubborn Problems

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

FAQPage Schema
How do I systematically debug a bug that won't go away after multiple fix attempts?

Systematic debugging applies a structured four-phase approach—Overview, Systematic Inspection, Root Cause Analysis, and Solution & Verification—to uncover hidden defects when quick fixes have failed. This methodology documents assumptions, categorizes defects, and uses think-aloud reasoning to prevent trial-and-error waste on complex, persistent issues.

When should I use the Five Whys technique for root cause analysis?

The Five Whys technique guides deep root cause analysis when a bug involves intricate system interactions or has resisted multiple previous attempts. It identifies fundamental issues rather than symptoms, ensuring you address the actual problem, not just surface-level manifestations.

What's the best way to approach bugs involving complex interactions between multiple services?

For bugs with intricate system interactions—like those between authentication services and databases—apply a modified Fagan Inspection process with mandatory phase-locked outputs and explicit assumption documentation. This structured approach prevents missed dependencies and ensures thorough investigation across system boundaries.

How does the Fagan Inspection methodology prevent bugs from recurring?

Fagan Inspection performs rigorous defect categorization and root cause analysis across four sequential phases, creating a verifiable solution plan. This comprehensive approach addresses underlying causes rather than symptoms, preventing the same bug from reappearing in production.

Do I need specialized tools to perform structured debugging for production issues?

Structured debugging relies on methodology—think-aloud reasoning, defect categorization, and systematic phase progression—rather than specialized tools. The approach applies to any technology stack dealing with persistent production bugs that have resisted multiple fix attempts.

What types of bugs benefit most from systematic inspection rather than quick troubleshooting?

Systematic inspection suits critical production bugs, problems involving multiple failed fix attempts, issues with intricate system dependencies, or cases where root cause remains unclear. Quick troubleshooting works for simple issues; systematic inspection solves stubborn, complex problems requiring thorough investigation.