systematic-debugging

Guide four-phase debugging from investigation to implementation with root cause analysis.

Updated Jan 15, 2026

Search Tags:#debugging #investigation #root cause #troubleshooting #error handling #bug fixing

Ready to run

npx skills add https://github.com/lips85/antigravity-skills-bootstrap --skill systematic-debugging-lips85

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/lips85/antigravity-skills-bootstrap/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/lips85/antigravity-skills-bootstrap --skill systematic-debugging-lips85

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill prevents wasted time and new bugs caused by quick fixes or symptom-based patching, ensuring that the true root cause of any technical issue is identified and resolved.

Core Features & Use Cases

Structured Investigation: Guides users through a mandatory four-phase process: Investigation, Pattern Analysis, Hypothesis, and Implementation.
Pressure Resistance: Includes explicit rules and anti-patterns to prevent shortcuts, especially under time pressure.
Use Case: When a critical bug appears in production, this Skill ensures the team doesn't just apply a band-aid but systematically finds and fixes the underlying architectural flaw, preventing recurrence.

Quick Start

When encountering a bug, load the systematic debugging skill and follow its four-phase process to find the root cause before proposing any fixes.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema

What is the best way to find the root cause of a bug instead of just fixing symptoms?▼

Systematic debugging enforces a four-phase methodology—Investigation, Pattern Analysis, Hypothesis, and Implementation—to identify root causes. It includes explicit rules to resist time pressure and avoid common rationalizations that lead to symptom-based patching.

How do I systematically debug complex technical issues?▼

To systematically debug complex technical issues, follow a mandatory four-phase process: gather evidence during Investigation, analyze patterns, test hypotheses, and implement fixes. This methodology emphasizes tracing data flow and resisting time pressure to avoid new bugs.

Why does quick bug fixing often cause new bugs in production systems?▼

Quick bug fixing causes new bugs because it patches symptoms without addressing the underlying architectural flaw. Symptom-based patching wastes time and risks recurrence, which is why a systematic investigation is required to find the true root cause before implementing any fixes.

How do I prevent time pressure from ruining my troubleshooting process?▼

To prevent time pressure from ruining troubleshooting, apply explicit rules and anti-patterns that block shortcuts during the debugging process. A structured methodology requires completing evidence gathering and hypothesis testing before moving to implementation, resisting rationalizations.

When should I use a structured investigation process for bug fixing?▼

You should use a structured investigation process for bug fixing when critical errors appear in production or complex systems. It ensures the team systematically finds and fixes underlying architectural flaws through data flow tracing, preventing recurrence and avoiding wasted time.