Fähigkeiten error-handling-patterns
📦

error-handling-patterns

Sicher

Implement Robust Error Handling Patterns

Auch verfügbar von: wshobson

Build more resilient applications by mastering error handling patterns including exceptions, Result types, retry logic, and circuit breakers across Python, TypeScript, Rust, and Go.

Unterstützt: Claude Codex Code(CC)
🥉 75 Bronze
1

Die Skill-ZIP herunterladen

2

In Claude hochladen

Gehe zu Einstellungen → Fähigkeiten → Skills → Skill hochladen

3

Einschalten und loslegen

Teste es

Verwendung von "error-handling-patterns". How do I handle errors when calling an external API?

Erwartetes Ergebnis:

For external API calls, implement multiple layers of error handling: (1) Custom exception hierarchy for different failure types, (2) Retry with exponential backoff for transient errors, (3) Circuit breaker to prevent cascading failures, (4) Graceful degradation with fallback data. Example approach: Create custom exceptions (NetworkError, TimeoutError, RateLimitError), wrap API calls in retry decorator with 3 attempts and exponential backoff, use circuit breaker to track failure rates, provide cached fallback when API is unavailable.

Verwendung von "error-handling-patterns". When should I use Result types instead of exceptions?

Erwartetes Ergebnis:

Use Result types for expected failures (validation errors, not found errors, business logic errors) where the caller should explicitly handle both success and failure cases. Use exceptions for truly exceptional situations (null pointers, out of memory, unexpected runtime errors). Result types make error handling explicit in the type system, forcing callers to consider failure cases. In TypeScript, Result<T, E> = { ok: true, value: T } | { ok: false, error: E }. In Rust, the ? operator and Result<T, E> type provide built-in support. This approach improves code readability and reduces unexpected runtime errors.

Sicherheitsaudit

Sicher
v1 • 2/24/2026

This skill is a documentation and educational resource about error handling patterns. The static scanner flagged 49 potential issues, but after evaluation all findings are FALSE POSITIVES. The detected patterns (backtick syntax examples, HTTP library examples, error categories) are educational code snippets in markdown documentation, not executable malicious code. No security concerns identified.

2
Gescannte Dateien
674
Analysierte Zeilen
0
befunde
1
Gesamtzahl Audits
Keine Sicherheitsprobleme gefunden
Auditiert von: claude

Qualitätsbewertung

38
Architektur
100
Wartbarkeit
87
Inhalt
50
Community
100
Sicherheit
100
Spezifikationskonformität

Was du bauen kannst

Improve Application Reliability

Add robust error handling to new or existing features with proper exception hierarchies and meaningful error messages.

Build Fault-Tolerant Systems

Implement retry logic, circuit breakers, and graceful degradation for distributed systems and microservices.

Learn Cross-Language Patterns

Understand error handling approaches across Python, TypeScript, Rust, and Go to choose the best approach for each situation.

Probiere diese Prompts

Basic Exception Handling 
Help me implement proper error handling for a function that fetches user data from a database. I want to create custom exception classes and handle different error scenarios appropriately.
Result Type Implementation 
Show me how to implement a Result type pattern in TypeScript for parsing JSON data. Include proper error types and chainable error handling.
Retry with Backoff 
Create a Python decorator that implements retry logic with exponential backoff for network calls. Handle different exception types and include configurable attempts.
Circuit Breaker Pattern 
Implement a circuit breaker pattern in Python to prevent cascading failures when calling an external API. Include closed, open, and half-open states.

Bewährte Verfahren

  • Fail fast by validating input early and providing meaningful error messages with context
  • Preserve error context including stack traces, timestamps, and relevant metadata
  • Handle errors at the appropriate level where you can meaningfully respond to them
  • Log errors appropriately - log unexpected errors, not expected validation failures

Vermeiden

  • Catching too broadly with generic Exception handlers that hide bugs
  • Empty catch blocks that silently swallow errors without logging or handling
  • Returning error codes instead of using proper exceptions or Result types
  • Ignoring async errors by not handling promise rejections properly

Häufig gestellte Fragen

What is the difference between exceptions and Result types?
Exceptions are traditional error handling that disrupts control flow with try-catch blocks. Result types are explicit success/failure types that require the caller to handle both cases. Result types make error handling visible in the type system and are common in functional programming languages like Rust and Haskell.
When should I use a circuit breaker?
Use a circuit breaker when calling external services or APIs that might become unavailable. It prevents cascading failures by failing fast when a service is down, rather than tying up resources with repeated failing requests. The circuit transitions between closed (normal), open (failing), and half-open (testing recovery) states.
How does exponential backoff work for retries?
Exponential backoff increases the wait time between retry attempts (e.g., 1 second, 2 seconds, 4 seconds, 8 seconds). This prevents overwhelming a failing service with repeated requests while still giving it time to recover. Add jitter (random variation) to prevent thundering herd problems.
What is graceful degradation?
Graceful degradation provides fallback functionality when an error occurs. For example, if a caching service fails, fall back to the database. If both fail, return cached stale data. The application continues to work with reduced functionality rather than failing completely.
Should I catch exceptions or let them propagate?
Catch exceptions only where you can meaningfully handle them. Let unexpected exceptions propagate to a centralized error handler that logs them appropriately. This prevents hiding bugs with overly broad catch blocks while ensuring errors are properly logged and reported.
How do I create meaningful error messages?
Good error messages include what failed, why it failed, and what action to take. Include relevant context like user IDs, request IDs, and timestamps. Avoid generic messages like 'Error occurred' - instead say 'Failed to fetch user profile for user ID 123: connection timeout after 30s'.

Entwicklerdetails

Autor

sickn33

Lizenz

MIT

Repository

https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/error-handling-patterns

Ref

main

Dateistruktur

📁 resources/

📄 implementation-playbook.md

📄 SKILL.md