debugging-and-error-recovery

Diagnose software failures through structured triage and reproducible root-cause steps.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/chenxingqiang/tdd-agent-skills --skill debugging-and-error-recovery-chenxingqiang
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: debugging-and-error-recovery
Source: https://github.com/chenxingqiang/tdd-agent-skills/tree/main/skills/debugging-and-error-recovery
Command: npx skills add https://github.com/chenxingqiang/tdd-agent-skills --skill debugging-and-error-recovery-chenxingqiang

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging with structured triage. When something breaks, stop guessing and follow a disciplined process to preserve evidence, locate the root cause, and apply a lasting fix.

Core Features & Use Cases

  • Stop-the-Line Rule: halt feature work to prevent cascading failures and preserve data.
  • Triage Checklist: reproduce, localize, reduce, and fix with a guided sequence.
  • Localize & Verify: identify the failing layer (UI, API, database, build tooling, external service, or test itself) and verify with end-to-end checks.
  • Guardrails & Verification: ensure changes pass tests and are validated end-to-end before resuming work.

Quick Start

Apply the triage process to a failing test or broken build and work through reproduction, localization, minimal reproduction, root-cause fix, and verification.

Frequently Asked Questions about debugging-and-error-recovery

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

FAQPage Schema
How do I debug a production incident without losing evidence?

Debugging a production incident requires a systematic triage process that halts feature work to preserve evidence and prevent cascading failures. You must follow a disciplined sequence to reproduce, localize, and fix the root cause.

What is the best way to find the root cause of a failing test?

Finding the root cause of a failing test involves a structured triage checklist that enforces stepwise localization. You must reduce the failure to a minimal reproduction, identify the exact failing layer, and apply a root-cause fix.

How do I localize a runtime bug across different software environments?

Localizing a runtime bug requires identifying the specific failing layer, whether UI, API, database, build tooling, external service, or the test itself. You must verify the localized layer with end-to-end checks before applying fixes.

Can I use structured triage for fixing broken software builds?

Yes, structured triage applies directly to broken software builds by enforcing reproduction, stepwise localization, and minimal reproduction. You must verify that your root-cause fix passes tests and is validated end-to-end before resuming work.

Why should I stop feature work when a production incident happens?

You should stop feature work during a production incident to enforce a stop-the-line rule, which prevents cascading failures and preserves data. This disciplined approach ensures you can locate the root cause and apply a lasting fix.

What are the limitations of guessing fixes instead of systematic debugging?

Guessing fixes bypasses stepwise localization and minimal reproduction, risking cascading failures and lost evidence. Systematic debugging enforces guardrails and end-to-end verification to ensure changes pass tests before resuming work.