skills.rest
alunadev
alunadevCOMMUNITY
Explore all skills by this author →
Website𝕏@adrianlunadiazGitHub

error-handling-patterns

Automate robust error-handling patterns across Python, TypeScript, Rust, and Go.

3|Updated Jan 20, 2026
Search Tags:#TypeScript#patterns#Python#error-handling#retry#circuit-breaker
One-click install
npx skills add https://github.com/alunadev/ald_skills --skill error-handling-patterns-alunadev
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/alunadev/ald_skills/tree/main/development/error-handling-patterns
Command: npx skills add https://github.com/alunadev/ald_skills --skill error-handling-patterns-alunadev

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Error handling is often ad-hoc and brittle, leading to unstable software, confusing logs, and poor user experiences. This Skill standardizes patterns for exceptions, Result types, retries, and circuit breakers to improve reliability and maintainability across languages.

Core Features & Use Cases

  • Comprehensive error classification across languages with clear hierarchies (e.g., ApplicationError, ValidationError, NotFoundError, ExternalServiceError).
  • Guided implementations of retry with exponential backoff, circuit breakers, and graceful degradation to tolerate transient failures.
  • Cross-language examples (Python, TypeScript, Rust, Go) illustrating practical usage in real projects.
  • Emphasis on context propagation, rich error messages, and observability for easier debugging.

Quick Start

Design a robust error-handling module for a REST API client and implement a circuit-breaker with retry logic.

Frequently Asked Questions about error-handling-patterns

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

FAQPage Schema
How do I implement a circuit breaker with retry logic for a REST API client?▼

Cross-language error handling patterns cover Python, TypeScript, Rust, and Go. These implementations enforce explicit error hierarchies like ApplicationError and ExternalServiceError, providing structured code examples that standardize resilience across distributed systems.

What is the best way to structure error hierarchies for distributed systems?▼

Retries with exponential backoff are necessary when handling frequent transient failures in API integrations, batch processing, and distributed systems. This pattern automates resilience by gradually increasing wait times between retry attempts to prevent overwhelming external services.

Does this error-handling approach work for both TypeScript and Python environments?▼

Graceful degradation improves error handling by allowing systems to maintain partial functionality during external service outages. Combined with circuit breakers and rich error messages, it ensures context propagation and observability for easier debugging in distributed systems.

Why does ad-hoc error handling lead to unstable software and confusing logs?▼

Context propagation in error messages provides essential debugging metadata by attaching specific application states to exceptions. This structured approach replaces ad-hoc handling, ensuring rich error messages and observability across API integrations and batch processing workflows.

Related Skills

Explore More Software Engineering Skills→
artivillaartivilla

sentry

Monitor errors and performance in Next.js applications with Sentry.

Community
Intermediate
jimmymalhanjimmymalhan
1

circuit-breaker

Halts operations after a specified number of consecutive failures using configurable thresholds and cooldown periods.

Community
Advanced
williamzujkowskiwilliamzujkowski
17

monitoring-observability

Diagnose performance degradation in distributed systems using Prometheus, Grafana, and OpenTelemetry.

Community
Advanced
maxjuniorbrmaxjuniorbr
2

error-handling-patterns

Standardize error handling, propagation, and graceful degradation in multi-service architectures.

Community
Advanced