{"enrichment":{"faq":[{"a":"error-handling-patterns teaches Python error handling through try-except blocks, custom exception hierarchies, and context managers for cleanup. The skill covers distinguishing between recoverable errors (retry candidates) and unrecoverable ones, using specific exception types rather than bare except clauses, and implementing graceful degradation when errors occur. Python examples show proper exception chaining and resource management patterns.","q":"How to handle errors in Python effectively?"},{"a":"error-handling-patterns explains the circuit breaker pattern as a resilience mechanism that prevents cascading failures by stopping requests to failing services. The pattern has three states: closed (normal operation), open (failing, reject requests), and half-open (testing recovery). This skill teaches implementation strategies for detecting failure thresholds, managing state transitions, and integrating circuit breakers into retry logic for fault-tolerant systems.","q":"What is the circuit breaker pattern and when should I use it?"},{"a":"error-handling-patterns contrasts Result types (used in Rust and TypeScript) with traditional exceptions. Result types make errors explicit in function signatures and force callers to handle them, while exceptions can be silently propagated. The skill covers when each approach excels: Results for predictable, recoverable errors; exceptions for unexpected failures. Examples show how languages like Rust use Result<T, E> for type-safe error handling.","q":"How do Result types compare to exceptions for error handling?"},{"a":"error-handling-patterns demonstrates retry logic patterns that attempt failed operations multiple times with increasing delays between attempts. Exponential backoff multiplies the delay after each failure (e.g., 1s, 2s, 4s, 8s) to avoid overwhelming recovering services. The skill covers jitter addition to prevent thundering herd problems, maximum retry limits, and integration with circuit breakers for comprehensive resilience in distributed systems.","q":"How do I implement retry logic with exponential backoff?"},{"a":"error-handling-patterns addresses async error handling across Promise-based systems (TypeScript/JavaScript) and concurrent patterns. Key practices include proper Promise rejection handling, avoiding unhandled rejections, using async/await with try-catch for readability, and managing errors in parallel operations. The skill teaches error aggregation when multiple async tasks fail, timeout handling for hanging operations, and context propagation in distributed tracing.","q":"What are best practices for handling async and concurrent errors?"},{"a":"error-handling-patterns guides designing exception hierarchies that reflect your application's error domain. Start with a base custom exception, then create specific subclasses for different error categories (validation, network, database, authorization). The skill emphasizes including context (error codes, messages, original cause) and avoiding overly deep hierarchies. Examples show language-specific implementations in Python and TypeScript for maintainable, debuggable error handling.","q":"How should I design a custom exception hierarchy?"}],"shadow_tags":["resilience-patterns","fault-tolerance","error-recovery","exception-design","failure-handling","defensive-coding","reliability-engineering","error-propagation","system-robustness","debugging-support"],"summary_rewrite":"This skill covers error handling strategies for building resilient applications across multiple languages. Learn when to use exceptions versus Result types, how to categorize recoverable and unrecoverable errors, and implement patterns like retry with exponential backoff and async error handling. Includes language-specific examples for Python, TypeScript, and Rust."},"files":[{"bytes":17198,"path":"plugins/developer-essentials/skills/error-handling-patterns/SKILL.md","sha256":"aa8f11361c893893a0007b58f9322bb92cfcffa5b7b91f506059935192a3e68d","url":"https://skillfed.io/files/HermeticOrmus/LibreUIUX-Claude-Code/error-handling-patterns/53d35ebf/SKILL.md"}],"id":"HermeticOrmus/LibreUIUX-Claude-Code/error-handling-patterns","links":{"html":"https://skillfed.io/HermeticOrmus/LibreUIUX-Claude-Code/error-handling-patterns","md":"https://skillfed.io/HermeticOrmus/LibreUIUX-Claude-Code/error-handling-patterns.md","repo":"https://github.com/HermeticOrmus/LibreUIUX-Claude-Code"},"meta":{"agents_supported":[],"first_seen":"2026-07-28","forks":12,"language":"Shell","last_updated":"2026-05-27","license":"MIT","name":"error-handling-patterns","publisher":"HermeticOrmus","stars":86},"relations":{"categories":["software-engineering","backend-development","reliability-engineering"],"similar":[{"id":"HermeticOrmus/LibreUIUX-Claude-Code/microservices-patterns"},{"id":"miles990/claude-software-skills/python"},{"id":"affaan-m/ECC/error-handling"},{"id":"xu-xiang/everything-claude-code-zh/python-patterns"},{"id":"CloudAI-X/claude-workflow-v2/error-handling"},{"id":"affaan-m/ECC/python-patterns"},{"id":"dadbodgeoff/drift/error-handling"},{"id":"wshobson/agents/error-handling-patterns"},{"id":"majesticlabs-dev/majestic-marketplace/etl-core-patterns"},{"id":"secondsky/claude-skills/microservices-patterns"}]},"slug":{"owner":"HermeticOrmus","repo":"LibreUIUX-Claude-Code","skill":"error-handling-patterns"},"version":"53d35ebf"}