kimchi:systematic-debugging

Enforce a four-phase debugging process to identify root causes before fixes.

8|Updated Jan 31, 2026
One-click install
npx skills add https://github.com/Tromml/kimchi --skill kimchi-systematic-debugging
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: kimchi:systematic-debugging
Source: https://github.com/Tromml/kimchi/tree/main/plugins/kimchi/skills/systematic-debugging
Command: npx skills add https://github.com/Tromml/kimchi --skill kimchi-systematic-debugging

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill prevents wasted time and new bugs by enforcing a rigorous, four-phase process to identify the root cause of any technical issue before attempting a fix.

Core Features & Use Cases

  • Structured Debugging: Guides users through observation, hypothesis, testing, and fixing phases.
  • Root Cause Analysis: Ensures that fixes address the fundamental problem, not just symptoms.
  • Use Case: When a critical test fails in production, this Skill ensures the team doesn't resort to quick, potentially harmful patches but instead systematically uncovers the underlying architectural flaw or code defect.

Quick Start

Use the kimchi:systematic-debugging skill to debug the intermittent test failure.

Frequently Asked Questions about kimchi:systematic-debugging

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

FAQPage Schema
What is a systematic debugging process for finding the root cause of software bugs?

A systematic debugging process enforces four phases—observation, hypothesis, testing, and root-cause fixing—to identify fundamental technical issues before proposing fixes, preventing symptom-based patches and architectural drift.

How do I fix intermittent test failures without introducing new bugs?

To fix intermittent test failures, follow a structured debugging approach of observing symptoms, forming hypotheses, testing them, and fixing the root cause to prevent quick, potentially harmful patches that create new bugs.

Why does patching symptoms instead of finding the root cause lead to architectural drift?

Patching symptoms causes architectural drift because it bypasses root cause analysis, leaving fundamental code defects intact and allowing superficial fixes to accumulate, which destabilizes the software architecture over time.

Can I use systematic debugging for build errors and performance issues, not just code bugs?

Yes, systematic debugging applies to all software development problems, including build errors, performance issues, and test failures, by enforcing the same observation, hypothesis, testing, and fixing phases.

What's the best way to troubleshoot complex technical issues in software development?

The best way to troubleshoot complex technical issues is using a rigorous four-phase debugging process that requires strict adherence to observation, hypothesis, testing, and root-cause fixing stages before attempting any fixes.

When should I not use quick patches for critical production test failures?

You should avoid quick patches for critical production test failures when they mask symptoms instead of addressing the root cause, as this prevents uncovering underlying architectural flaws and risks introducing new bugs.