debugging-and-error-recovery

Guide users through reproducing failures, narrowing down issues, and implementing fixes.

Updated May 25, 2026

Search Tags:#debugging #systematic approach #root cause analysis #bug fixing #error recovery

Ready to run

npx skills add https://github.com/huuhiep0303/s-tools --skill debugging-and-error-recovery-huuhiep0303

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: debugging-and-error-recovery
Source: https://github.com/huuhiep0303/s-tools/tree/main/.agents/skills/debugging-and-error-recovery
Command: npx skills add https://github.com/huuhiep0303/s-tools --skill debugging-and-error-recovery-huuhiep0303

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides a systematic approach to debugging and error recovery, helping users find and fix the root cause of issues more efficiently.

Core Features & Use Cases

Structured Triage: Offers a step-by-step checklist for debugging, from reproducing failures to verifying fixes.
Error-Specific Patterns: Provides guidance for common error scenarios like test failures, build errors, and runtime bugs.
Safe Fallback Patterns: Introduces safe fallbacks and graceful degradation techniques to handle unexpected errors.
Instrumentation Guidelines: Offers best practices for adding and removing logging to aid in debugging.
Common Rationalizations: Helps users avoid common mistakes in debugging processes.

Quick Start

Use the debugging-and-error-recovery skill to systematically debug a failing test by following the triage checklist.

Frequently Asked Questions about debugging-and-error-recovery

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

FAQPage Schema

What is a systematic approach to debugging and finding the root cause of a bug?▼

Systematic debugging follows a structured triage process to reproduce failures, systematically narrow down issues, and implement fixes. This approach prevents common rationalizations and ensures you resolve the actual root cause.

How do I fix failing tests and build errors using a structured debugging process?▼

Use error-specific debugging patterns tailored for test failures and build errors. Following a structured triage checklist helps you isolate the failure point, apply targeted fixes, and verify the resolution systematically.

How do I add logging and instrumentation correctly when troubleshooting runtime bugs?▼

Follow instrumentation guidelines for adding and removing logging strategically. This ensures effective data collection for troubleshooting runtime bugs without permanently cluttering the codebase or degrading system performance.

What are safe fallback patterns for error recovery and graceful degradation?▼

Safe fallback patterns introduce graceful degradation techniques to handle unexpected runtime errors. They ensure your system maintains partial functionality and recovers securely instead of experiencing a complete failure.

What common mistakes should I avoid during the bug fixing and error recovery process?▼

Avoid common rationalizations that bypass systematic root cause analysis during bug fixing. Recognizing these pitfalls keeps you anchored to a structured debugging process, preventing superficial patches and ineffective fixes.