systematic-debugging

Diagnose bugs through structured root-cause investigation before implementing fixes.

3|Updated Apr 1, 2026
One-click install
npx skills add https://github.com/vtgiang-dotcom/Solo-Code-Harness --skill systematic-debugging-vtgiang-dotcom
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/vtgiang-dotcom/Solo-Code-Harness/tree/main/.gemini/antigravity/skills/systematic-debugging
Command: npx skills add https://github.com/vtgiang-dotcom/Solo-Code-Harness --skill systematic-debugging-vtgiang-dotcom

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Diagnosing bugs, test failures, unexpected behavior, and errors before proposing fixes. This approach enforces root-cause investigation as the prerequisite to any remediation.

Core Features & Use Cases

  • Phase-0 Feedback Loop: Build a fast, red-capable repro that exposes the exact user-facing symptom.
  • Phase-1 Root Cause Investigation: Gather diagnostic data (logs, traces, environment) to locate the source of the bug.
  • Phase-2 Pattern Analysis: Compare against references and known-good patterns to identify diffs.
  • Phase-3 Hypothesis & Testing: Form a single, testable hypothesis and validate with minimal changes.
  • Phase-4 Implementation: Create a failing test case, apply a focused fix, and verify across the system.

Quick Start

Provide a fast, red-capable reproduction command that isolates the bug and surfaces the 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 find the root cause of a bug before attempting a fix?

Root cause analysis for debugging requires gathering diagnostic data like logs and traces to locate the source of a bug before proposing any fixes. A structured workflow enforces investigation through pattern analysis, hypothesis testing, and verification.

What is the best way to systematically debug failing unit, integration, or end-to-end tests?

Systematic debugging of unit, integration, and end-to-end tests uses a structured workflow: build a fast reproduction, investigate root causes, analyze patterns, test hypotheses, and implement fixes with a failing test case to verify the resolution.

How do I create a reliable reproduction for an unexpected API or UI error?

Create a fast, red-capable reproduction command that isolates the exact user-facing symptom and surfaces the root cause. This initial feedback loop exposes the specific failure before you proceed to deeper diagnostic investigation.

Does systematic debugging work for both API and UI failures?

Systematic debugging applies to diagnosing bugs across unit, integration, and end-to-end issues, including tests, APIs, and UI bugs. It enforces a consistent root-cause investigation workflow regardless of the specific software layer.

What steps are involved in root-cause analysis for software failures?

Root-cause analysis involves gathering diagnostic data to find the source, comparing against known-good patterns to identify diffs, forming a single testable hypothesis, applying a focused fix, and verifying across the system with a failing test case.

Why should I analyze patterns during a debugging session?

Pattern analysis during debugging compares the failing system against references and known-good patterns to identify diffs. This step isolates the specific divergence causing the failure before you form a testable hypothesis or implement a fix.