debugging-and-error-recovery

Guide structured debugging and error recovery for software development scenarios.

Updated Apr 1, 2026
One-click install
npx skills add https://github.com/moonshineTP/ATTT-20252 --skill debugging-and-error-recovery-moonshinetp
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: debugging-and-error-recovery
Source: https://github.com/moonshineTP/ATTT-20252/tree/main/.claude/skills/debugging-and-error-recovery
Command: npx skills add https://github.com/moonshineTP/ATTT-20252 --skill debugging-and-error-recovery-moonshinetp

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill provides a systematic approach to debugging and error recovery, helping users identify and fix the root cause of issues quickly and effectively.

Core Features & Use Cases

  • Systematic Debugging: Offers a structured process for identifying and resolving errors.
  • Triage Checklist: A comprehensive list to guide users through the debugging process.
  • Minimal Failing Case Creation: Helps isolate issues by simplifying inputs and removing unrelated code.
  • Root Cause Fixing: Emphasizes addressing the underlying issue rather than symptoms.
  • Error-Specific Patterns: Provides troubleshooting steps for common types of errors like test failures and build issues.
  • Safe Fallback Patterns: Offers code examples for handling errors gracefully.
  • Instrumentation Guidelines: Best practices for adding and removing logging and instrumentation.
  • Verification Steps: Ensures the root cause is addressed and the fix works as intended.

Quick Start

Run the debugging skill to diagnose and resolve the error in the current codebase.

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 software debugging and error recovery?

A systematic debugging approach provides a structured process to identify root causes and recover from errors. It involves triage, isolating minimal failing cases, and fixing underlying issues rather than just treating symptoms.

How do I find the root cause of a system troubleshooting issue?

To find the root cause during system troubleshooting, create a minimal failing case by simplifying inputs and removing unrelated code. This isolation helps pinpoint the exact trigger and apply a definitive fix.

What is the best way to handle build issues and test failures?

The best way to handle build issues and test failures is applying error-specific troubleshooting patterns. This structured method targets common failure types directly, ensuring you address the actual defect instead of surface symptoms.

How do I add instrumentation and logging for incident response?

Add instrumentation and logging during incident response by following established best practices for code observation. This involves strategically placing logs to capture failure states and removing them once the root cause is verified.

What are safe fallback patterns for handling software errors gracefully?

Safe fallback patterns provide code examples for handling errors gracefully, allowing software to recover or degrade securely during incidents. They ensure system stability while you execute the structured debugging process.

Do I need specific tools to isolate minimal failing cases during debugging?

You do not need specific external tools to isolate minimal failing cases. The process requires a basic understanding of software development principles to manually simplify inputs and remove unrelated code for effective error recovery.