systematic_debugging

Guide four-phase debugging from investigation through hypothesis testing to implementation.

Updated Dec 1, 2025
One-click install
npx skills add https://github.com/Come0520/L2C --skill systematic-debugging-come0520
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic_debugging
Source: https://github.com/Come0520/L2C/tree/main/.agent/skills/systematic-debugging
Command: npx skills add https://github.com/Come0520/L2C --skill systematic-debugging-come0520

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides a robust framework to systematically identify and resolve bugs, test failures, and unexpected behavior, preventing the common pitfalls of quick fixes and symptom-based patching.

Core Features & Use Cases

  • Structured Investigation: Guides users through a mandatory four-phase process (Investigation, Pattern Analysis, Hypothesis, Implementation).
  • Root Cause Mandate: Emphasizes finding the fundamental cause of an issue, not just addressing immediate symptoms.
  • Pressure Resistance: Includes specific rules and language designed to counteract time pressure and rationalization.
  • Use Case: When a critical test fails in CI, instead of guessing or adding arbitrary waits, use this Skill to methodically trace the error, identify the exact faulty logic, and implement a precise fix.

Quick Start

Use the systematic_debugging skill to investigate any bug or test failure you encounter.

Frequently Asked Questions about systematic_debugging

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

FAQPage Schema
How do I find the root cause of a bug instead of just fixing symptoms?▼

Systematic debugging prioritizes root cause analysis over symptom-fixing by guiding you through a mandatory four-phase process: investigation, pattern analysis, hypothesis testing, and implementation. This structured approach prevents quick fixes and arbitrary patches.

What is the best way to debug complex system failures with multiple components?▼

Debugging complex system failures requires tracing multi-component data flows through pattern analysis and defense-in-depth validation strategies. This systematic process isolates exact faulty logic across interconnected components rather than applying localized patches.

How do I stop guessing and systematically troubleshoot failing tests in CI?▼

To troubleshoot failing tests in CI without guessing, methodically trace the error through investigation and hypothesis testing phases. This identifies the exact faulty logic and enables a precise fix, avoiding arbitrary waits or symptom patching.

Can I use a structured debugging process to resist time pressure and rationalizations?▼

Yes, a structured debugging process includes specific rules and language designed to counteract time pressure and common rationalizations. It enforces a root cause mandate, ensuring thorough hypothesis validation before implementation.

When should I use a systematic debugging methodology over quick fixes?▼

Use a systematic debugging methodology when facing critical test failures, unexpected behavior, or complex multi-component issues. It is essential when quick fixes risk masking the fundamental cause rather than resolving the specific faulty logic.