systematic-debugging

Name: systematic-debugging
Availability: InStock
Author: charly3pins

Executes a four-phase investigative framework to identify and resolve software root causes.

4|Updated Dec 7, 2020

Search Tags:#quality assurance #debugging #problem solving #systematic approach #troubleshooting #root cause analysis #bug fixing

Ready to run

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

💬 Prompt for ChatGPT / Claude Chat▼

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Random fixes and quick patches waste time, mask underlying issues, and often introduce new bugs, leading to prolonged debugging cycles and fragile software.

Core Features & Use Cases

Four-Phase Framework: Enforces a structured process: Root Cause Investigation, Pattern Analysis, Hypothesis Testing, and Implementation.
Iron Law Enforcement: Mandates finding the root cause before any fixes, preventing symptom-based solutions and ensuring lasting repairs.
Rationalization Counters: Addresses common excuses for skipping the process, ensuring disciplined debugging even under intense pressure.
Use Case: When a critical production API is down and there's pressure for a quick fix, use this skill to resist the urge to patch symptoms and instead follow a systematic process to identify and resolve the true root cause.

Quick Start

I have encountered a test failure. Guide me through the systematic debugging process to find its root cause.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema

How do I debug a failing test systematically instead of applying quick fixes?▼

Systematic debugging follows a four-phase framework: Root Cause Investigation gathers evidence about the failure, Pattern Analysis identifies recurring conditions, Hypothesis Testing validates assumptions, and Implementation applies the root-cause fix. This process prevents symptom-based patches that mask underlying issues.

What's the best way to find the root cause of a production bug under time pressure?▼

Root cause analysis requires completing Phase 1 investigation before proposing any fix, even under pressure. Document evidence, perform pattern analysis to spot recurring triggers, formulate testable hypotheses, and only then implement lasting solutions. This resists the urge to patch symptoms.

Why do quick patches often fail to fix software problems permanently?▼

Quick patches address symptoms rather than root causes, leaving underlying issues intact. This creates fragile software, prolongs debugging cycles, and frequently introduces new bugs. Systematic debugging enforces finding the true cause first, ensuring durable repairs.

How do I apply a structured debugging process to build failures and integration issues?▼

Apply the four-phase framework to build and integration failures: investigate failure evidence with diagnostic instrumentation, analyze patterns across occurrences, test hypotheses about root causes, then implement solutions with traceability. This prevents jumping to configuration tweaks without understanding the failure.

Can systematic debugging help when troubleshooting unexpected behavior or performance problems?▼

Yes. Systematic debugging applies to unexpected behavior and performance problems by enforcing investigation before fixes, gathering measurable evidence, analyzing patterns, testing hypotheses, and implementing root-cause solutions with an anti-shortcut policy that maintains diagnostic traceability.

What prevents developers from skipping systematic debugging steps under deadline pressure?▼

Rationalization counters address common excuses for bypassing the process—such as 'we'll patch it later' or 'this is faster.' Enforcing the four-phase framework and Iron Law policy, which mandates finding root causes before any fix, ensures disciplined debugging even in high-stakes scenarios.