systematic-debugging

Guide teams through a 4-phase root-cause debugging workflow.

1|Updated Apr 30, 2025
One-click install
npx skills add https://github.com/lucasfth/config --skill systematic-debugging-lucasfth
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/lucasfth/config/tree/main/.hermes/skills/software-development/systematic-debugging
Command: npx skills add https://github.com/lucasfth/config --skill systematic-debugging-lucasfth

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill enforces a four-phase root-cause investigation before applying any fixes, reducing wasted effort and patchwork solutions.

Core Features & Use Cases

  • Four-phase root-cause investigation workflow that guides error analysis, reproduction, evidence gathering, and hypothesis testing.
  • Clear guardrails that prevent fixes until the root cause is understood.
  • Applicable to software bugs, test failures, and unexpected behavior across components.

Quick Start

Begin a root-cause investigation by reading the error, reproducing the issue, and tracing data flow before attempting any fixes.

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 a software bug before applying fixes?

Root-cause debugging requires a systematic workflow of evidence gathering, pattern analysis, and hypothesis testing to identify the underlying fault. This approach prevents patchwork solutions by enforcing investigation through four distinct phases before any code changes are attempted.

What is the best way to systematically debug unexpected behavior across multiple components?

Systematic debugging of unexpected behavior across components involves tracing data flow and reproducing the issue first. A structured investigation workflow guides teams through error analysis and evidence collection, ensuring the root cause is fully understood before implementing a fix.

How do I reproduce test failures to investigate the underlying fault?

Reproducing test failures starts by reading the error and tracing data flow to understand the failure context. The investigation process then moves to pattern analysis and hypothesis testing, documenting evidence at each step before proceeding to controlled implementation of a solution.

Can I use a systematic debugging workflow for runtime bugs in my codebase?

Yes, a systematic debugging workflow is directly applicable to codebases experiencing runtime bugs. It provides clear guardrails that prevent premature fixes, guiding teams through a four-phase root-cause investigation to ensure the underlying fault is identified and documented.

Why should I trace data flow before attempting to fix a software bug?

Tracing data flow before fixing a software bug ensures you gather sufficient evidence and understand the root cause. This prevents wasted effort on patchwork solutions by requiring hypothesis testing and pattern analysis to validate the underlying fault prior to any controlled implementation.

What are the limitations of fixing bugs without a root-cause investigation?

Fixing bugs without root-cause investigation often leads to wasted effort and patchwork solutions. Bypassing the evidence gathering, pattern analysis, and hypothesis testing phases increases the risk of unresolved underlying faults and recurring unexpected behavior across components.