systematic-debugging

Guide software debugging through a four-phase root cause analysis process.

Updated Mar 15, 2025

Search Tags:#debugging #root cause #troubleshooting #bug fixing #error resolution #systematic process

Ready to run

npx skills add https://github.com/farsink/Farsin-konnadan-portfolio --skill systematic-debugging-farsink

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/farsink/Farsin-konnadan-portfolio/tree/main/.agents/skills/systematic-debugging
Command: npx skills add https://github.com/farsink/Farsin-konnadan-portfolio --skill systematic-debugging-farsink

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 and symptom-based solutions, ensuring that the true root cause of any issue is identified and resolved systematically.

Core Features & Use Cases

Systematic Debugging: Guides users through a mandatory four-phase process (Investigation, Pattern Analysis, Hypothesis, Implementation) for any bug or unexpected behavior.
Root Cause Mandate: Emphasizes finding the underlying cause before any fixes are applied, preventing recurring issues.
Pressure Resistance: Includes specific language and structural defenses to combat time pressure and rationalization.
Use Case: When a critical API endpoint starts returning errors, this Skill ensures the engineer doesn't just add a quick retry, but thoroughly investigates why the connection is failing in the first place.

Quick Start

Use the systematic-debugging skill to investigate any bug you encounter.

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 software bugs instead of just fixing symptoms?▼

Systematic debugging requires finding the underlying root cause before applying any fixes. This approach uses a structured four-phase process—Investigation, Pattern Analysis, Hypothesis, and Implementation—to thoroughly investigate why an issue occurs rather than applying quick symptom-based solutions.

How do I troubleshoot unexpected errors without introducing new bugs?▼

To troubleshoot unexpected errors without introducing new bugs, follow a structured process that emphasizes thorough investigation and pattern analysis. You must test hypotheses and confirm the root cause before implementing fixes, which prevents recurring issues and avoids the pitfalls of quick patches.

Why does applying quick fixes often cause recurring issues in software troubleshooting?▼

Quick fixes often cause recurring issues because they address symptoms rather than the root cause. Without systematic debugging to identify why a failure happens in the first place, the underlying problem remains unresolved, leading to wasted time and new bugs.

Can I use a systematic debugging process for critical API endpoint failures?▼

Yes, you can use systematic debugging for critical API endpoint failures. Instead of adding a quick retry, the process guides you to thoroughly investigate why the connection is failing in the first place, ensuring the true root cause of the error resolution is identified and resolved.

How to resist pressure to apply quick symptom-based solutions during critical bug fixing?▼

To resist pressure during critical bug fixing, systematic debugging includes specific language and structural defenses against time pressure and rationalization. These rules combat the urge to apply symptom-based solutions, enforcing a mandatory four-phase process before any implementation.

What are the limitations of using a systematic debugging process for troubleshooting?▼

The main limitation of systematic debugging is that it resists rapid, symptom-based patches, which may feel slow under severe time pressure. However, this constraint is intentional, preventing new bugs and ensuring true error resolution through strict process adherence and anti-pattern avoidance.