error-handling-patterns

Standardize error handling patterns across Python, TypeScript, Rust, and Go codebases.

1|Updated Apr 27, 2026
One-click install
npx skills add https://github.com/haxlys/skills --skill error-handling-patterns-haxlys
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/haxlys/skills/tree/main/vendored/wshobson-agents/plugins/developer-essentials/skills/error-handling-patterns
Command: npx skills add https://github.com/haxlys/skills --skill error-handling-patterns-haxlys

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability.

Core Features & Use Cases

  • Cross-language error patterns: exceptions, result types, and error codes are standardized to improve maintainability.
  • Resilient API design: structured errors, retry strategies, and circuit-breaker integration for fault tolerance.
  • Observability and debugging: rich context in error messages and propagation traces to simplify debugging.

Quick Start

Use a consistent error-handling strategy across new features and services to ensure predictable failure modes.

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 standardize error handling across Python, TypeScript, Rust, and Go?

To standardize error handling across Python, TypeScript, Rust, and Go, apply language-idiomatic patterns like exceptions and Result types to ensure structured error propagation and predictable failure modes in multi-language codebases.

How do I implement retry logic and circuit breakers for resilient API design?

Implementing retry logic and circuit breakers for resilient API design requires integrating structured error types and fault tolerance strategies to achieve graceful degradation and reliable error propagation in distributed systems.

When do I need Result types instead of exceptions for error propagation?

You need Result types instead of exceptions for error propagation when working in languages like Rust or Go that enforce explicit error handling, ensuring structured error types and clear messaging across multi-language codebases.

How do I add observability context to error messages for debugging distributed systems?

Adding observability context to error messages for debugging distributed systems involves enforcing structured error types and rich propagation traces, which simplifies tracking reliable error propagation across API services and data pipelines.

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

Yes, this error handling approach works for API services and data pipelines by enforcing structured error types, retry strategies, and graceful degradation to ensure reliable error propagation across distributed systems.