systematic-debugging

Investigate root causes through a four-phase debugging framework.

Updated Nov 22, 2025

Search Tags:#testing #debugging #root cause #troubleshooting #software quality #reliability

Ready to run

npx skills add https://github.com/tom-xs/nixos-dotfiles --skill systematic-debugging-tom-xs

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/tom-xs/nixos-dotfiles/tree/main/ai/kimi-skills/skills/systematic-debugging
Command: npx skills add https://github.com/tom-xs/nixos-dotfiles --skill systematic-debugging-tom-xs

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill prevents the common trap of applying quick, superficial fixes to symptoms, which often leads to recurring issues, technical debt, and wasted time. It enforces a rigorous, scientific approach to debugging that ensures problems are resolved permanently.

Core Features & Use Cases

Root Cause Mandate: Forces a structured investigation phase before any code changes are made.
Multi-Layer Validation: Provides techniques like defense-in-depth and condition-based waiting to make bugs structurally impossible.
Use Case: Use this when you are facing a persistent test failure or production bug and are tempted to apply a quick fix without fully understanding the underlying trigger.

Quick Start

Load the systematic-debugging skill and follow the four-phase process to investigate the root cause of the current issue before proposing any code changes.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema

What is systematic debugging and how does it resolve software bugs?▼

To debug software systematically, follow a strict four-phase protocol: investigate the issue, analyze patterns, test hypotheses, and implement changes. This enforces a root cause mandate before any code modifications occur.

How do I fix a persistent test failure without creating technical debt?▼

To fix a persistent test failure without technical debt, apply a structured investigation phase to discover the root cause trigger before making code changes. This prevents recurring issues caused by quick superficial patches.

What's the best way to troubleshoot production bugs and performance regressions?▼

The best way to troubleshoot production bugs and performance regressions is using a scientific debugging approach with multi-layer validation. This applies pattern analysis and hypothesis testing to ensure architectural integrity and make bugs structurally impossible.

When should I use a root cause analysis approach for troubleshooting?▼

You should use a root cause analysis approach for troubleshooting whenever you face persistent test failures, production bugs, or performance regressions and are tempted to apply a quick fix without fully understanding the underlying trigger.

Does systematic debugging work for performance regressions in complex software?▼

Yes, systematic debugging works for performance regressions by applying strict investigation, pattern analysis, and hypothesis testing protocols. This multi-layer validation technique ensures architectural integrity while resolving the underlying issue.