systematic-debugging

Execute a four-phase debugging workflow to identify and resolve technical root causes.

9|Updated Jul 1, 2026

Search Tags:#debugging #investigation #troubleshooting #problem-solving #root-cause

Ready to run

npx skills add https://github.com/Cyapstaye/Adame_ver.open --skill systematic-debugging-cyapstaye

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Cyapstaye/Adame_ver.open/tree/main/skills/software-development/systematic-debugging
Command: npx skills add https://github.com/Cyapstaye/Adame_ver.open --skill systematic-debugging-cyapstaye

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill prevents the common pitfall of applying superficial patches to complex technical issues, ensuring that the underlying root cause is identified and resolved to prevent recurring bugs.

Core Features & Use Cases

Four-Phase Methodology: Guides the agent through investigation, pattern analysis, hypothesis testing, and implementation.
Evidence-Based Debugging: Enforces strict data flow tracing and instrumentation before any code changes are made.
Use Case: When a production service experiences intermittent failures, this skill forces the agent to gather logs, reproduce the issue, and verify the fix with a regression test rather than guessing at the cause.

Quick Start

Use the systematic-debugging skill to investigate the failing test case in the current module by following the four-phase process.

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 intermittent production failures instead of applying superficial patches?▼

Root cause analysis for production failures requires a systematic four-phase workflow: evidence gathering, pattern analysis, hypothesis testing, and implementation. This enforces strict data flow tracing and instrumentation before any code changes are made to prevent recurring bugs.

What is the best way to troubleshoot unexpected performance regressions across multi-component architectures?▼

Troubleshooting performance regressions across multi-component architectures demands hypothesis-driven testing and rigorous evidence gathering. A structured methodology guides you through investigation and regression verification to ensure durable code fixes rather than guessing at the cause.

How do I debug failing test cases systematically without guessing at the cause?▼

Debugging failing test cases systematically involves following a four-phase process to investigate the failing module. You must gather logs, reproduce the issue accurately, and verify the implemented fix with a regression test to resolve the technical root cause.

Why do my software bug fixes keep recurring in different forms?▼

Software bug fixes keep recurring when superficial patches are applied to complex technical issues without identifying the underlying root cause. Implementing evidence-based debugging with strict data flow tracing ensures the actual problem is resolved to prevent recurring bugs.

Can I use systematic debugging for investigating test failures in any software system?▼

Systematic debugging applies to troubleshooting production bugs, test failures, and unexpected performance regressions across multi-component architectures. It requires gathering evidence, hypothesis-driven testing, and regression verification to ensure durable code fixes regardless of the system.

When should I not use a hypothesis-driven testing approach for troubleshooting?▼

Hypothesis-driven troubleshooting should not be used when you lack the ability to gather logs or reproduce the issue. The methodology strictly enforces data flow tracing and instrumentation before any code changes are made, requiring verifiable evidence to proceed.