systematic-debugging

Diagnose root causes of bugs using a reproducible, testable debugging loop.

15|2|Updated May 23, 2026
One-click install
npx skills add https://github.com/VKirill/antigravity-for-claude-code --skill systematic-debugging-vkirill
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/VKirill/antigravity-for-claude-code/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/VKirill/antigravity-for-claude-code --skill systematic-debugging-vkirill

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Systematic debugging prevents symptom-suppression by guiding you to reproduce a failure, isolate the smallest changing factor, identify the true root cause, and ship a root-cause fix with a regression test.

Core Features & Use Cases

  • Canonical root-cause workflow: symptom characterization, testable hypothesis, one-variable-at-a-time testing, bisect, root-cause naming, and verification.
  • Repeatable reproduction & bisection: turns flaky or “it worked yesterday” bugs into deterministic investigations using minimal repro and commit-range binary search.
  • Targeted diagnosis tools: log-driven debugging, runtime debugging, and graph-aware tracing to understand data flow and call impact.

Use it when a test started failing, behavior changed after an unrelated refactor, production-only errors can’t be reproduced locally, or “fixes” keep coming back.

Quick Start

Ask an AI to diagnose a failing test with systematic-debugging by reproducing the bug first, then running one hypothesis-test step at a time until the root cause is named and a regression test is added.

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 test failure instead of just suppressing the symptom?

Root cause analysis for test failures requires reproducing the bug reliably, characterizing expected versus actual behavior, and testing one variable at a time. You form and falsify hypotheses until isolating the true root cause, then ship a fix with a regression test.

What is the best way to debug flaky issues that only happen in production?

Debug flaky production-only issues by creating a minimal reproduction case and using log-driven debugging. When timeline-based, apply git bisect to perform commit-range binary search, turning unpredictable incidents into deterministic investigations.

How do I systematically debug an unexpected behavior change after a refactor?

Systematically debug behavior changes after a refactor by first reproducing the failure, then isolating the smallest changing factor. Use one-variable-at-a-time testing or git bisect to locate the exact commit causing the regression.

When should I use git bisect for debugging?

Use git bisect for debugging when a failure is timeline-based, such as behavior that worked yesterday but broke today. It performs commit-range binary search to pinpoint the exact commit introducing the bug, turning "it worked before" into a deterministic investigation.

Why do my bug fixes keep coming back after I deploy them?

Bug fixes keep coming back when symptom-suppression occurs instead of root-cause fixing. Prevent recurring issues by isolating the true root cause through hypothesis testing, implementing a root-cause fix, and adding a regression test that fails without the fix.

Can I use hypothesis testing to diagnose deterministic and flaky failures?

Hypothesis testing diagnoses both deterministic and flaky failures by applying a stepwise debugging loop. You reproduce the issue, form testable hypotheses about the root cause, and falsify them with one-variable changes until the root cause is named.