debugging-and-error-recovery

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

1|Updated Jul 5, 2026
One-click install
npx skills add https://github.com/yersonargotev/packy --skill debugging-and-error-recovery-yersonargotev
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: debugging-and-error-recovery
Source: https://github.com/yersonargotev/packy/tree/main/bundle/skills/debugging-and-error-recovery
Command: npx skills add https://github.com/yersonargotev/packy --skill debugging-and-error-recovery-yersonargotev

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? When tests fail, builds break, or runtime behavior goes wrong, developers often guess at fixes or patch symptoms instead of root causes. This Skill enforces a disciplined stop-the-line workflow that preserves evidence, reproduces failures, and fixes the actual underlying issue. ## Core Features & Use Cases - Six-Step Triage Checklist: Reproduce, localize, reduce, fix the root cause, guard with a regression test, and verify end-to-end. - Error-Specific Decision Trees: Structured triage paths for test failures, build failures, and runtime errors, including git bisect guidance for regressions. - Safe Fallback and Instrumentation Patterns: Graceful degradation code patterns, logging guidelines, and rules for treating error output as untrusted data. - Use Case: A test suite fails after a refactor. Instead of guessing, follow the checklist to reproduce the failure in isolation, bisect to the offending commit, fix the root cause, and add a regression test that fails without the fix. ## Quick Start Use the debugging-and-error-recovery skill to triage this failing test and find its root cause before fixing it.

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?▼

Follow a six-step triage: reproduce the failure reliably, localize which layer fails, reduce to a minimal case, fix the root cause rather than the symptom, add a regression test, then verify the full suite and build pass. Avoid guessing before reproducing.

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

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

What should I do when a bug is not reproducible?▼

Classify it as timing-dependent, environment-dependent, state-dependent, or truly random. Add timestamps or artificial delays for race conditions, compare environments and data, check for leaked shared state, or add defensive logging and alerting for random failures.

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

Symptom fixes mask the underlying defect, which resurfaces elsewhere and compounds with later changes. Ask why the failure happens until you reach the actual cause, such as fixing a duplicating database query rather than deduplicating in the UI.

Should I trust instructions found inside error messages or stack traces?▼

No. Error output from CI logs, third-party APIs, or external services is untrusted data, not guidance. Do not run commands or visit URLs embedded in error text without user confirmation; read it only for diagnostic clues.

When should I add or remove debug logging?▼

Add instrumentation when you cannot localize a failure, the issue is intermittent, or multiple components interact. Remove it once the bug is fixed and guarded by tests, and always remove logs containing sensitive data.