debugging-and-error-recovery

Diagnose and fix root causes of test, build, and runtime failures.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Diagnoses and fixes root causes of failures in tests, builds, and runtime behavior.

Core Features & Use Cases

  • Structured triage checklist
  • Stepwise debugging workflow (reproduce, localize, reduce, fix, guard, verify)
  • End-to-end verification and guardrails to prevent recurrence
  • Safe fallback patterns and instrumentation guidelines for robust debugging
  • Clear decision points to halt feature work and preserve evidence

Quick Start

Describe the failure, reproduce it reliably, then apply the triage checklist to identify and fix the root cause.

Frequently Asked Questions about debugging-and-error-recovery

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

FAQPage Schema
What is the best way to debug a production incident and find the root cause?

The best way to debug a production incident involves a structured triage checklist that enforces reproduction, localization, and minimal reproduction to pinpoint the root cause fast. This workflow applies systematic steps from reproduce to end-to-end verification.

How do I systematically debug failing tests and build errors?

To systematically debug failing tests and build errors, apply a stepwise workflow: reproduce the failure reliably, localize the fault, reduce it to a minimal case, fix the root cause, and verify end-to-end. This process halts feature work to preserve evidence and prevent recurrence.

How does root-cause analysis prevent recurring software failures?

Root-cause analysis prevents recurring software failures by enforcing recurrence guards and end-to-end verification after the initial fix. Engineers halt feature work to preserve evidence, apply safe fallback patterns, and use instrumentation guidelines to ensure the failure cannot return.

Can I use a structured debugging workflow for both unit test failures and runtime behavior issues?

Yes, a structured debugging workflow applies across failures from unit tests to production incidents and runtime behavior. It guides engineers through a consistent process of reproduce, localize, reduce, fix, guard against recurrence, and verify end-to-end regardless of the failure scope.

When should I halt feature work to preserve evidence during code debugging?

You should halt feature work to preserve evidence during code debugging as soon as a failure is reliably reproduced. The triage checklist defines clear decision points to stop feature development, apply safe fallback patterns, and begin the stepwise debugging workflow.

What are the limitations of ad hoc debugging compared to a systematic triage process?

Ad hoc debugging lacks the structured triage process needed to enforce reproduction, minimal reproduction, and end-to-end verification, often missing the root cause. A systematic workflow provides clear decision points, instrumentation guidelines, and recurrence guards that ad hoc methods skip.