systematic-debugging

Diagnose and eliminate root causes of bugs using a four-phase debugging framework.

Updated Nov 3, 2025

Search Tags:#workflow #debugging #investigation #root cause #problem solving #troubleshooting #bug fix

Ready to run

npx skills add https://github.com/ayourtch/kimichat --skill systematic-debugging-ayourtch

💬 Prompt for ChatGPT / Claude Chat▼

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates wasted time on random fixes and symptom-treating, ensuring you always find and address the true root cause of any technical issue, even under pressure.

Core Features & Use Cases

Four-Phase Framework: Guides through investigation, pattern analysis, hypothesis testing, and implementation for a structured approach to any bug.
Root Cause Mandate: Strictly enforces finding the root cause before proposing any fixes, preventing "whack-a-mole" debugging.
Pressure Resistance: Designed to prevent shortcuts and rationalizations, even under tight deadlines or high stress, ensuring thoroughness.
Use Case: When a critical production API is failing, use this skill to systematically investigate error messages, reproduce the issue, and trace data flow before attempting any quick fixes.

Quick Start

I'm using the systematic-debugging skill to investigate the PaymentError: Connection timeout in the production logs.

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 requires a structured investigation: gather evidence, reproduce the issue consistently, trace the data flow to identify where the failure originates, then test hypotheses before implementing a fix. This systematic approach prevents treating symptoms and ensures the real problem is resolved.

What's the best way to debug a production failure under time pressure?▼

Apply a four-phase debugging framework: investigate the failure and collect evidence, analyze patterns in the data, form and test hypotheses about the root cause, then implement a single fix based on your findings. This structured method resists shortcuts and ensures thoroughness even during high-stress situations.

How do I troubleshoot test failures and build integration issues systematically?▼

Debugging test failures and integration problems uses the same root-cause methodology: reproduce the failure, gather diagnostic data, trace execution flow to identify where the breakdown occurs, and validate your hypothesis before fixing. This prevents repeating the same errors across different contexts.

Can I use systematic debugging for performance problems and unexpected behavior?▼

Yes, systematic debugging applies to any technical issue including performance degradation and unexpected behavior. The four-phase framework—investigation, pattern analysis, hypothesis testing, and root-cause implementation—works across all failure types by enforcing evidence collection and reproducibility.

Why does treating symptoms without finding root cause waste time?▼

Symptom-focused fixes address only the visible problem, leaving the underlying cause to resurface repeatedly in different forms. Systematic debugging eliminates this cycle by requiring evidence collection, data-flow tracing, and hypothesis validation to identify and fix the true root cause once.

What are the anti-patterns I should avoid when debugging technical issues?▼

Avoid random fixes, skipping evidence collection, failing to reproduce issues consistently, and implementing changes without hypothesis validation. The systematic framework enforces stopping points and anti-pattern detection to prevent these common debugging traps that waste resources.