skills.rest
GaryOcean428
GaryOcean428COMMUNITY
Explore all skills by this author →
WebsiteGitHub

systematic-debugging

Guide a four-phase debugging process prioritizing root cause investigation.

Updated Feb 16, 2026
Search Tags:#testing#debugging#investigation#troubleshooting#root cause analysis#bug fixing
One-click install
npx skills add https://github.com/GaryOcean428/vex-agent --skill systematic-debugging-garyocean428
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/GaryOcean428/vex-agent/tree/main/.agents/skills/systematic-debugging
Command: npx skills add https://github.com/GaryOcean428/vex-agent --skill systematic-debugging-garyocean428

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 by enforcing a rigorous, systematic approach to debugging, ensuring that the root cause of an issue is identified and addressed before any fixes are implemented.

Core Features & Use Cases

  • Root Cause Investigation: Guides users through careful error analysis, reproduction steps, and evidence gathering.
  • Pattern Analysis: Helps identify similarities to working code and understand dependencies.
  • Hypothesis Testing: Promotes a scientific method for proposing and testing single, minimal fixes.
  • Implementation & Verification: Ensures fixes are targeted, tested, and verified against the root cause.
  • Architectural Questioning: Provides a framework for identifying and addressing fundamental architectural flaws when multiple fixes fail.
  • Use Case: When a critical bug appears in production, this Skill ensures the team doesn't resort to quick, superficial fixes but instead systematically uncovers and resolves the underlying problem, preventing recurrence.

Quick Start

Use the systematic-debugging skill to investigate any bug, test failure, or unexpected behavior before proposing fixes.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I perform root cause analysis for a production bug instead of just fixing the symptom?▼

Root cause analysis for a production bug requires a structured investigation process that gathers evidence, reproduces the error, and tests single minimal hypotheses before implementing targeted fixes. This approach prevents superficial patches and recurring regressions.

What is the best way to systematically debug test failures and unexpected software behavior?▼

Systematically debugging test failures involves a four-phase process: careful error analysis, pattern comparison against working code, scientific hypothesis testing, and rigorous implementation verification to ensure the underlying issue is fully resolved.

Why do my bug fixes keep causing new regressions in my codebase?▼

Bug fixes often cause regressions when developers apply quick superficial patches instead of identifying the actual root cause. Enforcing structured analysis and targeted verification before deploying changes prevents new defects from emerging.

When should I question the software architecture during troubleshooting?▼

You should question software architecture during troubleshooting when multiple isolated bug fixes fail to resolve the issue. This indicates fundamental architectural flaws that require broader structural changes rather than localized patches.

Can I use a systematic debugging approach for performance problems and not just functional errors?▼

Yes, systematic debugging applies to performance problems by enforcing evidence gathering, error reproduction, and hypothesis testing. This structured investigation identifies the root cause of performance degradation just as effectively as functional bugs.

Does systematic debugging require any specific testing frameworks or dependencies to work?▼

Systematic debugging requires no specific testing frameworks or external dependencies. It provides a methodology for root cause investigation and hypothesis verification that integrates directly into your existing software engineering workflow.

Related Skills

Explore More Software Engineering Skills→
FoundationForgeFoundationForge

debug

Run structured debugging sessions to reproduce, isolate, and diagnose software errors.

Official
Intermediate
CyapstayeCyapstaye
9

test-driven-development

Enforce the Red-Green-Refactor cycle with failing tests before implementation.

Community
Advanced
muhammadhamad1104muhammadhamad1104

ios-fix

Detect, fix, and verify iOS bugs using Bash scripts and source code analysis.

Community
Advanced
brixtonphambrixtonpham

Root Cause Tracing

Trace call sequences backward to identify original triggers of deep-stack errors.

Community
Advanced