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.