skills.rest
NAMEWTA
NAMEWTACOMMUNITY
Explore all skills by this author →
GitHub

debugging-and-error-recovery

Diagnose test failures, build errors, and runtime bugs through a structured root-cause triage workflow.

2|Updated Jul 6, 2026
Search Tags:#debugging#root cause analysis#regression testing#triage#error recovery#git bisect#test failure
One-click install
npx skills add https://github.com/NAMEWTA/learning-open-code --skill debugging-and-error-recovery-namewta
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: debugging-and-error-recovery
Source: https://github.com/NAMEWTA/learning-open-code/tree/main/translator/open-ai-skills/addyosmani-agent-skills/skills/debugging-and-error-recovery
Command: npx skills add https://github.com/NAMEWTA/learning-open-code --skill debugging-and-error-recovery-namewta

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? When tests fail, builds break, or runtime behavior diverges from expectations, developers often guess at fixes and patch symptoms instead of root causes. This Skill enforces a disciplined six-step triage process that stops feature work, preserves evidence, and drives the fix to the actual root cause. ## Core Features & Use Cases - Six-Step Triage Checklist: Reproduce, localize, minimize, fix the root cause, add a regression test, and verify end-to-end. - Error-Type Decision Trees: Dedicated classification flows for test failures, build failures, and runtime errors, plus git bisect guidance for regressions. - Safe Fallback Patterns: Code patterns for graceful degradation, defensive defaults, and instrumentation guidance on when to add or remove logging. - Use Case: A CI build suddenly fails after a merge. Follow the checklist to reproduce locally, bisect to the offending commit, fix the underlying cause, and add a regression test before continuing. ## Quick Start Use the debugging-and-error-recovery skill to systematically diagnose why my test suite started failing after the last commit 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
How do I debug a failing test systematically?▼

Run the failing test in isolation with verbose output to reproduce it reliably, then determine whether the test or the code is wrong. Check for shared state, timing issues, or order dependencies before changing any code.

How to find which commit introduced a bug with git bisect?▼

Run git bisect start, mark the current commit as bad and a known working commit as good, then test each midpoint checkout. You can automate it with git bisect run followed by your test command.

What should I do when a bug cannot be reproduced?▼

Gather more context such as logs and environment details, then test timing, environment, and state-related hypotheses. Add defensive logging and monitoring, and document observed conditions until it recurs.

Why is fixing symptoms instead of root causes a problem?▼

Symptom-level fixes mask the underlying defect, which resurfaces elsewhere and compounds with later changes. The workflow requires asking why the failure occurred until the true cause is found and covered by a regression test.

When should I add or remove debug logging?▼

Add instrumentation when you cannot localize a failure or the issue is intermittent, and remove it once the bug is fixed and covered by a test. Keep permanent logging only for error boundaries, API error context, and key performance metrics.

Related Skills

Explore More Software Engineering Skills→
mvillmowmvillmow
18

extract-test-failures

Parse test logs to extract and categorize failures by type.

Community
Basic
zeroclash-labszeroclash-labs

fix-issue

Resolve GitHub issues by implementing minimal fixes and verifying with cargo test.

Official
Advanced
neuron-oneneuron-one
25

monitoring

Automate application and server monitoring with error tracking, metrics, and alerting.

Community
Intermediate
truongnattruongnat
1

bug-discovery-pro

Identify and triage evidence-backed defect candidates in large codebases.

Community
Advanced