error-handling-patterns

Standardize error handling with retries, circuit breakers, and context-rich errors.

Updated Jan 17, 2026
One-click install
npx skills add https://github.com/AndyMarigoldLabs/continuous-funding --skill error-handling-patterns-andymarigoldlabs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/AndyMarigoldLabs/continuous-funding/tree/main/.codex/skills/error-handling-patterns
Command: npx skills add https://github.com/AndyMarigoldLabs/continuous-funding --skill error-handling-patterns-andymarigoldlabs

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

Error handling patterns are essential to build resilient applications and reduce debugging time by standardizing how failures are detected, reported, and recovered from.

Core Features & Use Cases

  • Pattern library: provides language-agnostic approaches (exceptions, result types, error codes, and option/maybe types) for modeling failures.
  • Context-rich errors: designed with codes, messages, and metadata to simplify debugging and monitoring.
  • Resilience primitives: retry strategies, exponential backoff, and circuit breakers to prevent cascading failures.
  • Graceful degradation: fallbacks and safe fallouts when dependencies fail, preserving partial functionality.
  • Cross-language guidance: examples in Python, TypeScript, Rust, and Go for quick adoption in real projects.

Quick Start

Review the included examples and templates in Python, TypeScript, Rust, and Go, and adapt them to your project to begin implementing robust error handling today.

Frequently Asked Questions about error-handling-patterns

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

FAQPage Schema
What's the best way to implement error handling across Python, TypeScript, Rust, and Go?

Cross-language error handling standardizes failures using language-specific patterns. This approach enforces explicit error types and context preservation to build resilient applications consistently across Python, TypeScript, Rust, and Go.

How do I prevent cascading failures when a service dependency crashes?

Prevent cascading failures by applying resilience primitives like retry strategies, exponential backoff, and circuit breakers. These patterns stop processes from repeatedly hitting broken dependencies, isolating faults and maintaining overall system stability.

How do I preserve context in error messages to simplify debugging?

Preserve context in error messages by building context-rich errors. Structure your failures with specific codes, descriptive messages, and metadata to simplify debugging and monitoring across your fault-tolerant systems.

Does this approach support graceful degradation when API integrations fail?

Graceful degradation is supported through fallbacks and safe defaults. When dependencies fail, this pattern preserves partial functionality and prevents total application failure during API design and service integration.

When should I use result types instead of standard exceptions?

Use result types instead of exceptions when working in languages like Rust or Go that favor explicit error handling. Result types model failures as values, enforcing explicit checks and reducing unhandled exceptions in fault-tolerant systems.