failure-recovery

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

1|Updated Feb 22, 2026
One-click install
npx skills add https://github.com/Rynaro/homunculus --skill failure-recovery-rynaro
Or copy as Structured Prompt for Agent
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.