systematic-debugging

Trace software failures to root causes through a four-phase debugging process.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/kivilaid/plugin-marketplace --skill systematic-debugging-kivilaid
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/kivilaid/plugin-marketplace/tree/main/plugins/systematic-debugging
Command: npx skills add https://github.com/kivilaid/plugin-marketplace --skill systematic-debugging-kivilaid

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a rigorous, four-phase framework to systematically debug any technical issue, preventing the common trap of fixing symptoms instead of root causes. It ensures you thoroughly understand the problem before attempting solutions, saving countless hours of "whack-a-mole" debugging.

Core Features & Use Cases

  • Root Cause Investigation: Guides you to carefully read errors, reproduce issues, check changes, and gather evidence in multi-component systems.
  • Pattern Analysis & Hypothesis Testing: Helps identify underlying patterns, form single, testable hypotheses, and verify them minimally.
  • Defensive Implementation: Ensures fixes target the root cause and encourages adding validation layers to prevent recurrence.
  • Use Case: When a complex system fails, use this Skill to methodically trace the error through multiple layers, identify the exact point of failure, and implement a robust solution that prevents future regressions.

Quick Start

Observe the symptom (e.g., an error message)

Error: git init failed in /Users/jesse/project/packages/core

Then, follow the tracing process:

1. Find Immediate Cause

2. Ask: What Called This?

3. Keep Tracing Up

4. Find Original Trigger

Example diagnostic logging:

console.error('DEBUG git init:', { directory, cwd: process.cwd(), nodeEnv: process.env.NODE_ENV, stack: new Error().stack, });

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?

Root cause analysis traces a bug back to its original trigger by systematically investigating each layer—reading error messages, reproducing the issue, checking recent changes, and gathering evidence across components. This prevents recurring bugs and wasted debugging time.

What's the best way to debug complex failures across multiple systems?

Systematic debugging follows a four-phase process: gather symptoms and evidence, analyze patterns to form testable hypotheses, verify the hypothesis minimally, then implement fixes targeting the root cause. This approach works for test failures, production bugs, performance problems, and build failures.

How do I stop wasting time on whack-a-mole debugging?

Enforce a core rule: no fixes without root-cause investigation. Use diagnostic instrumentation to log context, trace upward through callers and dependencies, and identify the exact point of failure before implementing solutions.

When should I use systematic debugging versus quick fixes?

Use systematic debugging for any technical issue with unclear cause—test failures, production bugs, performance problems, and emergencies. It applies universally; quick fixes often mask root causes and create future regressions.

What diagnostic practices prevent bugs from recurring?

Add validation layers and defensive implementation after identifying root cause. Log relevant context—working directory, environment variables, stack traces—to enable tracing and reduce debugging time for similar issues.