systematic-debugging

Enforce root cause investigation before fixing software bugs.

Updated Aug 23, 2026

Search Tags:#debugging #anti-patterns #root cause #systematic #test failures #software

Ready to run

npx skills add https://github.com/tDalile/dotfiles --skill systematic-debugging-tdalile

💬 Prompt for ChatGPT / Claude Chat▼

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents wasted time and new bugs caused by fixing symptoms instead of root causes, providing a disciplined process for debugging any software issue, test failure, or unexpected behavior.

Core Features & Use Cases

Four‑phase systematic process: root‑cause investigation, pattern analysis, hypothesis testing, and implementation.
Anti‑pattern guidance: explicit warnings against shortcuts, quick fixes, and multiple simultaneous changes.
Pressure‑resistant rules: mandatory pauses and language that enforce correct steps even under tight deadlines.
Testing framework: includes validation scenarios to ensure the process works in academic, time‑pressure, and complex environments.
Applicable contexts: production incidents, CI failures, performance problems, and integration issues.

Quick Start

Invoke systematic-debugging to guide you through root‑cause investigation for the current issue.

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 when should I use it?▼

Systematic debugging is a disciplined four-phase process to find and fix software bugs by investigating root causes first. Use it for any test failure, unexpected behavior, or production incident to prevent fixing symptoms and causing new bugs.

How do I debug test failures without introducing new bugs?▼

To debug test failures without new bugs, follow a four-phase process: investigate the root cause, analyze patterns, test hypotheses, and implement the fix. Avoid shortcuts and making multiple simultaneous changes to ensure the actual issue is resolved.

What is the best way to find the root cause of a production incident?▼

The best way to find the root cause of a production incident is to enforce root-cause investigation before applying any fix. Mandatory pauses and anti-pattern guidelines help maintain discipline and avoid quick fixes even under tight deadline pressure.

Can I use this systematic debugging process for CI failures and performance problems?▼

Yes, you can use this systematic debugging process for CI failures, performance problems, and integration issues. It applies to any software debugging task or unexpected behavior across any development environment by enforcing structured hypothesis testing.

Why does my quick fix keep causing new software bugs?▼

Quick fixes cause new software bugs because they address symptoms instead of the root cause. By enforcing pattern analysis and hypothesis testing before implementation, this systematic process prevents the wasted time and cascading failures associated with shortcuts.

What are the limitations of using a systematic debugging process under tight deadlines?▼

Under tight deadlines, the limitation is the required time for mandatory pauses and root-cause investigation. However, these pressure-resistant rules are enforced specifically to prevent the costly shortcuts and multiple simultaneous changes that worsen complex software issues.