systematic-debugging

Enforce a structured root-cause debugging workflow with evidence gathering and hypothesis testing.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/mlamla123/openclaw-starter-kit --skill systematic-debugging-mlamla123
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/mlamla123/openclaw-starter-kit/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/mlamla123/openclaw-starter-kit --skill systematic-debugging-mlamla123

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Four-phase debugging methodology focused on root-cause analysis to prevent symptom fixes and reduce debugging time.

Core Features & Use Cases

  • Phase-based workflow: Root Cause Investigation, Pattern Analysis, Hypothesis + Testing, Implementation, Verification, and Documentation.
  • Supports evidence gathering, hypothesis documentation, and defense-in-depth validation.
  • Applicable to test failures, runtime bugs, performance issues, and complex debugging scenarios.

Quick Start

Begin Phase 1: Root Cause Investigation, gather evidence, and document the root cause before attempting any fixes.

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 how does it fix runtime bugs?

Systematic debugging enforces a structured, root-cause-driven workflow to solve runtime bugs. It replaces ad-hoc debugging with explicit phases for evidence gathering, hypothesis testing, and defense-in-depth validation to ensure verifiable fixes and prevent regressions.

How do I find the root cause of a test failure using a structured workflow?

To find the root cause of a test failure, begin with Phase 1: Root Cause Investigation. Gather evidence and document the root cause through pattern analysis and hypothesis testing before attempting any code fixes to avoid masking the actual issue.

What is the best way to debug performance regressions without fixing symptoms?

The best way to debug performance regressions without fixing symptoms is applying a hypothesis-driven methodology. Document evidence, test hypotheses systematically, and implement defense-in-depth validation to verify the fix addresses the true root cause.

Can I use this systematic debugging workflow for complex codebase issues?

Yes, you can use this systematic debugging workflow for complex codebase issues. It applies a root-cause-driven methodology across diverse codebases to handle test failures, runtime bugs, and performance issues while preventing future regressions.

How do I validate a bug fix to prevent future regressions?

You validate a bug fix to prevent regressions through defense-in-depth validation and documentation. The workflow requires verifying the fix against gathered evidence and tested hypotheses before completing the implementation phase.

Why does ad-hoc debugging fail to resolve complex software issues?

Ad-hoc debugging fails to resolve complex software issues because it lacks structured root-cause analysis. Without explicit evidence gathering and hypothesis testing, developers risk applying symptom fixes that cause future regressions instead of verifiable solutions.