systematic-debugging

Enforce root-cause investigation before implementing fixes for technical issues.

Updated May 2, 2026
One-click install
npx skills add https://github.com/artgaurav16420-oss/Mega-Skills --skill systematic-debugging-artgaurav16420-oss
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/artgaurav16420-oss/Mega-Skills/tree/main/distribution/harnesses/tabnine/agent/skills/systematic-debugging
Command: npx skills add https://github.com/artgaurav16420-oss/Mega-Skills --skill systematic-debugging-artgaurav16420-oss

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Bugs and failures are often addressed with quick patches that fix symptoms instead of root causes. Systematic Debugging provides a disciplined, phase-driven framework to identify and fix the underlying issue before acting.

Core Features & Use Cases

  • Phase-based workflow (Phase 1: Root Cause Investigation, Phase 2: Pattern Analysis, Phase 3: Hypothesis & Testing, Phase 4: Implementation) to guide problem solving.
  • Anti-patterns and defensive practices (STOP and re-analyze, defense-in-depth) to resist shortcuts under pressure.
  • Real-world applicability to tests, production bugs, flaky behavior, and integration issues; reduces time-to-resolve and reduces regression risk.

Quick Start

Load this skill and begin with Phase 1: Root Cause Investigation before proposing any fixes.

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 production bug before applying a fix?

To find the root cause of a production bug, you must investigate systematically before fixing. This means enforcing a four-phase approach starting with root cause investigation, then pattern analysis, hypothesis testing, and finally implementation.

What is the best way to debug flaky tests and integration issues systematically?

The best way to debug flaky tests and integration issues is using a phase-driven framework. It forces root cause investigation and pattern analysis before implementing fixes, reducing time-to-resolve and minimizing regression risk.

Why do quick patches fail to resolve unexpected software behavior permanently?

Quick patches fail to resolve unexpected software behavior permanently because they fix symptoms instead of root causes. A disciplined debugging process identifies the underlying issue first, resisting shortcuts under pressure through anti-patterns and defensive practices.

How do I start a systematic debugging workflow for an unresolved technical issue?

To start a systematic debugging workflow, begin with Phase 1: Root Cause Investigation. You must complete Phases 1 through 4, which include pattern analysis and hypothesis testing, before proposing or implementing any code fixes.

Does defense-in-depth debugging work for complex production bugs?

Defense-in-depth debugging works for complex production bugs by applying a structured, four-phase investigation process. It includes explicit steps, anti-patterns, and guardrails to resist shortcuts under pressure, ensuring underlying issues are fully addressed.

What are the limitations of using a phase-based debugging process?

The limitation of a phase-based debugging process is the strict requirement to complete all four investigation phases before implementing fixes. This disciplined approach resists quick patches, which may slow down immediate symptom relief under pressure.