skills.rest
Zhijiang-Li1111
Zhijiang-Li1111COMMUNITY
Explore all skills by this author →
GitHub

systematic-debugging

Identify root causes of bugs and failing tests through structured investigation.

10|2|Updated Mar 26, 2026
Search Tags:#tdd#debugging#systematic#code-quality#reproducibility#root-cause#hypothesis-testing
One-click install
npx skills add https://github.com/Zhijiang-Li1111/ironflow --skill systematic-debugging-zhijiang-li1111
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Zhijiang-Li1111/ironflow/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/Zhijiang-Li1111/ironflow --skill systematic-debugging-zhijiang-li1111

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Identify root causes efficiently by guiding structured investigation rather than trial-and-error, reducing time to fix and preventing regressions.

Core Features & Use Cases

  • Phase-driven debugging: Root-cause investigation, pattern analysis, hypothesis testing, and fix-with-TDD.
  • Guardrails and escalation: Clear decision points to escalate to spec-first when architectural changes are needed.
  • Reproducibility and diagnostics: Ensure reproducible failures with diagnostic steps and verifiable fixes.
  • Use Case: When a bug is reported or a test fails, follow a disciplined process to trace the failure to its source and verify the fix with tests.

Quick Start

Start by forming a single hypothesis, reproduce the failure, and test one focused change at a time to identify the root cause.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is the best way to find the root cause of a flaky test or build failure?▼

Structured root-cause investigation replaces trial-and-error debugging by guiding you through pattern analysis and hypothesis testing to identify the source of failing tests or build failures efficiently.

How do I debug an unexpected software behavior across components systematically?▼

To debug unexpected software behavior across components, you form a single hypothesis, reproduce the failure with diagnostic steps, test one focused change at a time, and apply a TDD-based fix to verify the root cause is resolved.

Does structured debugging work with TDD-based fixes for user-reported bugs?▼

Yes, structured debugging integrates TDD-based fixes by tracing the user-reported problem to its source through hypothesis testing, then verifying the resolution with reproducible diagnostic steps and tests to prevent regressions.

When should I escalate a bug investigation to spec-first architectural changes?▼

You should escalate a bug investigation to spec-first when clear decision points indicate that architectural changes are needed, moving beyond standard hypothesis testing to address fundamental structural issues.

Why does trial-and-error debugging fail to prevent regressions effectively?▼

Trial-and-error debugging fails to prevent regressions because it lacks reproducibility and pattern analysis, whereas a structured investigation ensures verifiable fixes through phased root-cause identification and TDD-based testing.

Related Skills

Explore More Software Engineering Skills→
derHakenderHaken
437

systematic-debugging

Trace data flow and apply a four-phase process to fix root causes.

Community
Advanced
kdlbskdlbs
562

fix

Reproduce bugs, identify root causes, and implement minimal fixes with regression tests.

Official
Intermediate
fum1plefum1ple

spec-reader

Locate and read project specification files to summarize acceptance criteria.

Community
Basic
lava-chenlava-chen
1

debug-strategy

Diagnose software bugs through structured root-cause analysis and hypothesis testing workflows.

Community
Intermediate