skills.rest
ucirello
ucirelloCOMMUNITY
Explore all skills by this author →
GitHub

systematic-debugging

Investigate root causes through four-phase hypothesis testing and verified fixes.

2|Updated Jan 27, 2026
Search Tags:#testing#debugging#troubleshooting#software development#root cause analysis#bug fixing
One-click install
npx skills add https://github.com/ucirello/sgai --skill systematic-debugging-ucirello
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/ucirello/sgai/tree/main/cmd/sgai/skel/.sgai/skills/systematic-debugging
Command: npx skills add https://github.com/ucirello/sgai --skill systematic-debugging-ucirello

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the common issue of inefficient and ineffective debugging by enforcing a structured, four-phase approach to identify and fix bugs, preventing wasted time and the introduction of new issues.

Core Features & Use Cases

  • Root Cause Investigation: Ensures thorough analysis of errors, reproduction steps, and system changes before any fixes are attempted.
  • Pattern Analysis: Guides the identification of similar working patterns and understanding of dependencies to inform solutions.
  • Hypothesis Testing: Promotes a scientific approach with minimal, verifiable changes to test hypotheses.
  • Implementation with Verification: Mandates failing test cases and single, verified fixes to ensure the root cause is resolved.
  • Use Case: When a critical test fails in a CI/CD pipeline, this Skill will be invoked to systematically investigate the failure, ensuring the underlying cause is found and fixed, rather than applying a quick patch that might break something else.

Quick Start

Use the systematic-debugging skill to investigate the current test failure.

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 do I need it for software troubleshooting?▼

Systematic debugging is a structured four-phase framework for software troubleshooting. You need it when investigating complex bugs, ensuring thorough root cause analysis, pattern evaluation, and verified implementation rather than applying quick patches.

How do I find the root cause of a bug instead of applying a quick patch?▼

To find a bug's root cause, investigate errors and reproduction steps, analyze working patterns and dependencies, test hypotheses with minimal changes, and implement verified fixes using failing test cases to ensure the underlying issue is resolved.

What's the best way to debug a failing test in a CI/CD pipeline?▼

The best way to debug a failing CI/CD pipeline test involves a structured approach: investigate the failure's root cause, analyze system dependencies, test hypotheses with verifiable changes, and mandate failing test cases before applying a single verified fix.

How do I verify a bug fix without introducing new software issues?▼

Verify a bug fix without introducing new issues by using hypothesis testing with minimal changes, creating failing test cases that reproduce the bug, and implementing a single verified fix to ensure the root cause is resolved effectively.

Does systematic debugging work with test-driven development workflows?▼

Yes, systematic debugging integrates directly with test-driven development workflows. It mandates failing test cases during the hypothesis testing phase and uses single, verified fixes to ensure root causes are resolved without regressions.

Why should I analyze similar working patterns when troubleshooting software?▼

Analyzing similar working patterns during troubleshooting informs your solution by highlighting functional dependencies and code behaviors. This pattern analysis precedes hypothesis testing, ensuring your bug fixing approach is grounded in proven system mechanics.

Related Skills

Explore More Software Engineering Skills→
sQVesQVe

debug-issue

Diagnose bugs by tracing evidence and generating a BR issue template.

Community
Advanced
allexcdallexcd

autonomous-bug-fixing

Diagnose, reproduce, and fix code defects from bug reports or error logs.

Community
Advanced
ntaksh42ntaksh42
1

systematic-debugging

Guides users through a four-phase debugging process to resolve software defects via root cause analysis and hypothesis testing.

Community
Advanced
Pepsi1978Pepsi1978
1

resilient-bugfixing

Automate bugfixing with root-cause analysis, defensive patching, and validation.

Community
Advanced