error-handling-patterns

Standardize error handling with circuit breakers and retry logic across Python, TypeScript, Rust, and Go.

7|Updated Mar 15, 2026
One-click install
npx skills add https://github.com/Cobalt-Money/Cobalt --skill error-handling-patterns-cobalt-money
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/Cobalt-Money/Cobalt/tree/main/.agents/skills/error-handling-patterns
Command: npx skills add https://github.com/Cobalt-Money/Cobalt --skill error-handling-patterns-cobalt-money

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the challenge of building robust software by providing standardized patterns for managing failures, preventing cascading errors, and ensuring graceful degradation in complex systems.

Core Features & Use Cases

  • Resilience Patterns: Implements circuit breakers and retry logic with exponential backoff to handle transient service failures.
  • Error Strategy Design: Provides guidance on choosing between exceptions, Result types, and error codes based on language-specific best practices.
  • Use Case: When integrating multiple external financial APIs, use this Skill to implement a circuit breaker that prevents your application from hanging when a specific provider experiences downtime.

Quick Start

Apply the error-handling-patterns skill to refactor the current module by implementing a custom Result type and adding a retry decorator to all external network calls.

Frequently Asked Questions about error-handling-patterns

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

FAQPage Schema
How do I prevent cascading failures when integrating external financial APIs?

Implement a circuit breaker pattern to prevent cascading failures when integrating external financial APIs. This strategy stops your application from hanging during provider downtime by isolating faults and ensuring graceful degradation across distributed systems.

What is the best way to standardize error handling across Python, TypeScript, Rust, and Go?

The best way to standardize error handling across Python, TypeScript, Rust, and Go is to apply language-idiomatic practices like Result types or exceptions. This ensures consistent error propagation, logging, and resource cleanup throughout your application architecture.

How do I implement retry logic with exponential backoff for transient service failures?

You can implement retry logic with exponential backoff for transient service failures by applying resilience patterns. This approach standardizes error handling strategies, automatically retrying failed network calls with increasing delays to improve application reliability.

Should I use exceptions, Result types, or error codes for error strategy design?

Your choice between exceptions, Result types, and error codes for error strategy design depends on language-specific best practices. Standardizing on the idiomatic approach for your environment ensures consistent error propagation and robust resource cleanup.

How do I refactor an existing module to add a custom Result type and retry decorator?

To refactor an existing module to add a custom Result type and retry decorator, apply standardized error handling patterns to all external network calls. This process enforces consistent error propagation, logging, and graceful degradation throughout your codebase.