debugging-and-error-recovery

Diagnose software failures with a structured 6-step triage workflow.

Updated Jun 1, 2026
One-click install
npx skills add https://github.com/j-cogburn/d3 --skill debugging-and-error-recovery-j-cogburn
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: debugging-and-error-recovery
Source: https://github.com/j-cogburn/d3/tree/main/tests/project-t01/.d3/skills/debugging-and-error-recovery
Command: npx skills add https://github.com/j-cogburn/d3 --skill debugging-and-error-recovery-j-cogburn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the wasted time and compounded errors that come from guessing at bug fixes or addressing only symptoms instead of root causes. It provides a structured, repeatable process to diagnose, fix, and guard against any unexpected failure in tests, builds, runtime behavior, or production systems.

Core Features & Use Cases

  • Stop-the-Line Rule: Prevents error compounding by halting feature work when unexpected issues arise, preserving evidence, and fixing root causes before resuming development.
  • 6-Step Triage Checklist: A repeatable workflow covering reproduction, localization, reduction to a minimal failing case, root cause fixing, recurrence guarding, and end-to-end verification.
  • Error-Specific Patterns: Tailored triage steps for test failures, build breaks, and runtime errors, plus safe fallback patterns for time-pressured scenarios.
  • Safety Guardrails: Rules for treating error output as untrusted data, common rationalization red flags, and instrumentation guidelines to avoid introducing new issues during debugging. Use case example: If your test suite fails after a code change, this Skill guides you to reproduce the failure, isolate the affected layer, create a minimal reproduction, fix the underlying issue (not just the test output), add a regression test, and verify the full suite passes without side effects.

Quick Start

Use the debugging-and-error-recovery skill to diagnose and fix the failing test suite after your latest code change, following the structured triage process to identify the root cause and add a regression test to prevent recurrence.

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 find the root cause of a failing test instead of just fixing the symptom?

To find the root cause of a failing test, use a structured 6-step triage workflow: reproduce the failure, localize the affected layer, reduce to a minimal failing case, fix the underlying issue, add a regression test, and verify the suite passes.

What is the best way to troubleshoot build breaks and runtime bugs systematically?

The best way to troubleshoot build breaks and runtime bugs systematically is to apply error-specific triage patterns that treat error output as untrusted data, preserving evidence and halting feature work to prevent error compounding.

Why do my software bug fixes keep causing new errors in production?

Software bug fixes cause new errors when you guess at solutions or address symptoms instead of root causes. Applying a stop-the-line rule and using instrumentation guardrails prevents introducing new issues during debugging.

Can I use a structured debugging workflow for frontend, backend, and database incidents?

Yes, you can use a structured debugging workflow for frontend, backend, database, build tooling, and external service layer incidents. It provides tailored triage steps for test failures, build breaks, and runtime errors across all layers.

What should I do to prevent error recurrence after fixing an unexpected production failure?

To prevent error recurrence after fixing a production failure, you must add regression tests and perform end-to-end verification. This ensures the full suite passes without side effects and guards against the same error happening again.

When should I use safe fallback patterns during test failure triage?

You should use safe fallback patterns during test failure triage in time-pressured scenarios where immediate recovery is needed. These patterns provide safe recovery guidelines while still adhering to root-cause debugging principles.