error-handling-patterns

Explain error handling patterns for Python, TypeScript, Rust, and Go.

Updated Dec 23, 2025
One-click install
npx skills add https://github.com/drgaciw/academic-compliance-hub-glm --skill error-handling-patterns-drgaciw
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/drgaciw/academic-compliance-hub-glm/tree/main/agents/plugins/developer-essentials/skills/error-handling-patterns
Command: npx skills add https://github.com/drgaciw/academic-compliance-hub-glm --skill error-handling-patterns-drgaciw

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill helps developers implement robust error handling strategies to build more resilient applications, gracefully manage failures, and improve debugging experiences.

Core Features & Use Cases

  • Master Error Handling Philosophies: Understand exceptions, Result types, error codes, and Option/Maybe types.
  • Implement Language-Specific Patterns: Learn Python, TypeScript/JavaScript, Rust, and Go error handling techniques.
  • Apply Universal Patterns: Utilize Circuit Breaker, Error Aggregation, and Graceful Degradation.
  • Use Case: When developing a new microservice, use this Skill to ensure all API endpoints handle potential network failures, invalid inputs, and downstream service errors gracefully, preventing cascading failures.

Quick Start

Explain the circuit breaker pattern for handling external API failures.

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 circuit breaker patterns for handling external API failures?

The circuit breaker pattern prevents cascading failures by blocking requests to failing external APIs. This Skill provides guidance on implementing circuit breakers alongside error aggregation and graceful degradation to ensure application resilience during network failures.

What is the best way to handle errors in Rust and Go using Result types?

Handling errors in Rust and Go is best achieved using Result types and error codes instead of exceptions. This Skill covers language-specific patterns, helping you implement custom error hierarchies and manage failures explicitly across multiple programming languages.

How does error aggregation improve application reliability and debugging?

Error aggregation improves application reliability by collecting multiple errors simultaneously rather than failing on the first. This Skill explains how combining aggregation with graceful degradation allows applications to maintain partial functionality during partial failures.

Can I use standard exception handling patterns for microservices in Python and TypeScript?

Standard exception handling in Python and TypeScript is covered extensively for microservices. This Skill demonstrates how to manage invalid inputs, downstream service errors, and network failures gracefully across API endpoints to prevent cascading failures.

When do I need custom error hierarchies instead of generic exceptions?

Custom error hierarchies are needed when managing complex application states and domain-specific failures. This Skill guides you through creating structured error hierarchies and utilizing Option or Maybe types to improve debugging experiences and application reliability.