failure-recovery

Classify, debug, and fix software failures using evidence-based protocols.

1|Updated Feb 22, 2026

Search Tags:#testing #debugging #troubleshooting #error handling #regression #code repair

Ready to run

npx skills add https://github.com/Rynaro/homunculus --skill failure-recovery-rynaro

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: failure-recovery
Source: https://github.com/Rynaro/homunculus/tree/main/.claude/skills/failure-recovery
Command: npx skills add https://github.com/Rynaro/homunculus --skill failure-recovery-rynaro

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a structured approach to diagnosing and resolving software failures, ensuring that fixes are targeted, evidence-based, and do not introduce regressions.

Core Features & Use Cases

Failure Classification: Categorizes errors into predefined types (e.g., TEST_ASSERTION, BUILD_ERROR).
Root Cause Analysis: Guides through a step-by-step process to identify the origin of a failure.
Targeted Fix Generation: Helps formulate specific, minimal code changes to address the root cause.
Use Case: When a build fails due to a Rubocop: Method has too many lines error, this Skill helps classify it as a LINT_VIOLATION, guides you to the specific line, and suggests a minimal refactoring to address the complexity.

Quick Start

Use the failure-recovery skill to classify and debug the provided test assertion failure.

Frequently Asked Questions about failure-recovery

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

FAQPage Schema

How do I debug and fix code failures systematically in a brownfield codebase?▼

To debug code failures systematically, you can classify errors into predefined types like TEST_ASSERTION or BUILD_ERROR, perform root cause analysis using concrete evidence, and generate targeted minimal code repairs to prevent regressions.

What is the best way to troubleshoot a runtime exception without introducing new regressions?▼

Troubleshooting a runtime exception involves classifying the failure, identifying its origin through evidence-based root cause analysis, and applying minimal code changes guided by a retry decision matrix and loop detection to avoid introducing new regressions.

How do I classify build errors and lint violations to identify the correct fix?▼

Classifying build errors and lint violations involves categorizing them into predefined types such as BUILD_ERROR or LINT_VIOLATION, which guides you to the specific failing line and suggests a minimal refactoring to address the root cause.

How do I handle test assertion failures when my previous code fixes are not working?▼

Handling test assertion failures requires classifying the error, analyzing the root cause based on concrete evidence, and utilizing a retry decision matrix with loop detection to ensure efficient resolution or escalation when initial code repairs fail.

Does this systematic debugging approach work for all types of software failures?▼

This debugging approach works for common failure patterns in brownfield codebases, specifically addressing test assertions, build errors, runtime exceptions, and regressions by classifying them into predefined types for targeted, evidence-based fixing.

When should I escalate a code repair instead of continuing to retry the fix?▼

You should escalate a code repair when the retry decision matrix and loop detection identify that repeated targeted fixes are not resolving the failure, ensuring efficient resolution by avoiding endless debugging loops.