systematic-debugging

Investigate root causes of bugs before applying fixes.

7|1|Updated Mar 26, 2026
One-click install
npx skills add https://github.com/robertphyatt/ironclaude --skill systematic-debugging-robertphyatt
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/robertphyatt/ironclaude/tree/main/worker/skills/systematic-debugging
Command: npx skills add https://github.com/robertphyatt/ironclaude --skill systematic-debugging-robertphyatt

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic root-cause investigation before proposing fixes, preventing guess-and-check debugging by enforcing a structured investigative process.

Core Features & Use Cases

  • Phase 1: Reproduce and Document — Understand the symptom, reproduce the issue, and document exact error messages, stack traces, exit codes, and environment details.
  • Phase 2: Root Cause Investigation — Read failing code, identify origin of the error, check inputs, trace back to sources, and eliminate guesswork.
  • Phase 3: Plan Fix — Design minimal, verifiable changes and prepare a plan with file paths and rationale.
  • Phase 4: Verify Fix — Re-run the original failing scenario, validate the fix, check for regressions, and document the outcome.
  • Common scenarios include debugging user-reported bugs, failing tests, crashes, and performance issues.

Quick Start

Run the systematic-debugging workflow on a failing module to identify the root cause before applying 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 bug before applying a fix?

Systematic debugging enforces a structured workflow to investigate root causes before applying fixes, preventing guess-and-check debugging. It guides diagnosis through reproducing issues, forming hypotheses, testing them, planning minimal changes, and verifying outcomes across codebases.

What is the best way to debug failing tests and crashes across a codebase?

The best way to debug failing tests and crashes is to follow a structured workflow: reproduce the failure, read the failing code, identify the error origin, test hypotheses, plan verifiable changes, and re-run the original scenario to validate the fix and check for regressions.

How do I stop guess-and-check debugging when investigating user-reported bugs?

To stop guess-and-check debugging, enforce a structured investigative process. Reproduce the issue, document exact environment details, form hypotheses about the root cause, test them systematically, and verify the planned fix resolves the original failing scenario.

How does hypothesis testing work during code tracing for performance issues?

Hypothesis testing during code tracing involves reading the failing code, checking inputs, tracing them back to their sources to eliminate guesswork, and systematically testing your assumptions about the performance issue before planning a minimal, verifiable fix.

Can I use systematic debugging for reproducing issues with specific environment details and exit codes?

Yes, systematic debugging applies to reproducing issues by documenting exact error messages, stack traces, exit codes, and environment details. This structured investigation phase ensures you understand the symptom and can reliably reproduce the problem before fixing it.

What should I do to verify a fix and prevent regressions after a root cause investigation?

To verify a fix and prevent regressions, re-run the original failing scenario, validate that the minimal changes resolved the issue, check for regressions across the codebase, and document the final outcome of the systematic debugging workflow.