error-handling-patterns

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

2|Updated Jan 18, 2026

Search Tags:#debugging #error handling #exceptions #resilience #circuit breaker #result types

Ready to run

npx skills add https://github.com/as4584/antigravity-skills --skill error-handling-patterns-as4584

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/as4584/antigravity-skills/tree/main/agents-wshobson/plugins/developer-essentials/skills/error-handling-patterns
Command: npx skills add https://github.com/as4584/antigravity-skills --skill error-handling-patterns-as4584

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and 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 handle failures, and improve debugging experiences.

Core Features & Use Cases

Master error handling patterns: Learn about exceptions, Result types, error propagation, and graceful degradation across multiple programming languages (Python, TypeScript/JavaScript, Rust, Go).
Implement best practices: Understand concepts like circuit breakers, error aggregation, and graceful degradation.
Use Case: When developing a new microservice, use this Skill to ensure all potential failure points (network requests, database operations, invalid inputs) are handled with appropriate strategies like retries, circuit breakers, and clear error messages.

Quick Start

Use the error-handling-patterns skill to implement a circuit breaker pattern in Python for an external API call.

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 pattern for external API calls?▼

A circuit breaker pattern prevents cascading failures by wrapping external API calls in a state machine that tracks failures and temporarily blocks requests when a threshold is reached. This allows the system to recover gracefully instead of overwhelming the struggling service.

What is the best way to handle errors across different programming languages?▼

The best way to handle errors across languages is to use language-appropriate patterns like exceptions in Python and TypeScript, or Result types in Rust and Go. Proper error propagation and clear error messages ensure consistent failure management across your application stack.

How does graceful degradation improve application resilience?▼

Graceful degradation improves resilience by allowing an application to maintain partial functionality when a component fails, rather than crashing entirely. By providing fallback responses or disabling non-essential features, the system continues serving users during partial outages.

Should I use Result types or exceptions for error handling in my microservice?▼

You should use Result types for languages like Rust and Go where explicit error handling is idiomatic, while exceptions are standard in Python and TypeScript. Result types force you to handle errors at compile time, whereas exceptions offer control flow separation for unexpected failures.

What are common pitfalls when building error handling for network requests and database operations?▼

Common pitfalls when building error handling for network requests and database operations include swallowing exceptions without logging, using overly broad catch blocks, and lacking retry logic. Failing to implement error aggregation can also obscure the root cause of multiple simultaneous failures.