error-handling-patterns

Define cross-language error handling patterns with retry, circuit breakers, and Result types.

1|Updated Dec 23, 2025
One-click install
npx skills add https://github.com/ccf/claude-code-ccf-marketplace --skill error-handling-patterns-ccf
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/ccf/claude-code-ccf-marketplace/tree/main/plugins/developer-essentials/skills/error-handling-patterns
Command: npx skills add https://github.com/ccf/claude-code-ccf-marketplace --skill error-handling-patterns-ccf

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Error handling is inconsistent across languages, leading to fragile APIs and unclear failure modes. This Skill provides a unified set of patterns to design, implement, and maintain robust error handling across Python, TypeScript, Rust, and Go.

Core Features & Use Cases

  • Comprehensive pattern catalog covering Exceptions vs Result types, error codes, and explicit propagation in multiple languages.
  • Practical implementations of Retry with exponential backoff, Circuit Breakers, Error Aggregation, and Graceful Degradation.
  • Real-world use cases such as API clients, data pipelines, and microservice boundaries to illustrate reliable error handling.

Quick Start

  • Review the examples in the Skill to define a shared error hierarchy and standardize error interfaces.
  • Implement a reusable retry mechanism and a circuit-breaker pattern for external calls.
  • Apply graceful degradation strategies to downstream components when a failure occurs.

Frequently Asked Questions about error-handling-patterns

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

FAQPage Schema
What is the best way to handle errors consistently across Python, TypeScript, Rust, and Go?

Cross-language error handling standardizes failure modes using pattern catalogs covering exceptions, Result types, and explicit propagation to unify diverse language mechanics into robust, maintainable APIs.

How do I implement a circuit breaker and retry with exponential backoff for API clients?

Implementing retry with exponential backoff and circuit breakers for API clients involves applying concrete code templates that monitor failure rates and temporarily block calls to prevent cascading downstream failures.

When should I use Result types instead of exceptions for error propagation?

Use Result types for explicit error propagation in typed languages like Rust and TypeScript, whereas exceptions suit Python and Go to define shared hierarchies and standardize error interfaces clearly.

How do I apply graceful degradation strategies in microservice boundaries?

Graceful degradation at microservice boundaries applies fallback strategies to downstream components during failures, ensuring data pipelines and external calls maintain partial functionality instead of crashing entirely.

Does this error handling approach work for both data pipelines and microservices?

Yes, the cross-language error handling patterns address real-world use cases including data pipelines and microservice boundaries, providing reliable strategies for external calls and error aggregation across diverse architectures.