error-handling-patterns

Identify and apply error-handling patterns across languages for API, I/O, and concurrency scenarios.

Updated Feb 5, 2026
One-click install
npx skills add https://github.com/Parthivjoshi29/agent-skills-npm-package --skill error-handling-patterns-parthivjoshi29
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/Parthivjoshi29/agent-skills-npm-package/tree/main/skills/error-handling-patterns
Command: npx skills add https://github.com/Parthivjoshi29/agent-skills-npm-package --skill error-handling-patterns-parthivjoshi29

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill helps engineers implement robust error handling across languages, providing patterns, classifications, and practical examples to build resilient software.

Core Features & Use Cases

  • Cross-language patterns: Exceptions vs Result types, retry strategies, and circuit breakers to manage failures gracefully.
  • API design & observability: Standardized error types, propagation rules, structured logging, and monitoring to improve debuggability and reliability.
  • Real-world scenarios: Guidance for API errors, I/O failures, and concurrency issues in distributed systems with clear fallback strategies.

Quick Start

Run through the included error-handling patterns and adapt them to your project's languages.

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 handle API errors and I/O failures in distributed systems?

Robust error handling in distributed systems uses standardized error types, propagation rules, and circuit breakers to manage API and I/O failures gracefully. It ensures system resilience by applying retry strategies with safe fallbacks to prevent cascading breakdowns.

How do I implement retry strategies and circuit breakers for robust software design?

Implement retry strategies and circuit breakers by unifying cross-language error-handling patterns that define clear error types and safe fallbacks. This approach isolates failing components, applies structured retry logic, and maintains system availability during transient or sustained failures.

Should I use exceptions or Result types for error propagation in concurrent applications?

Choosing between exceptions and Result types for concurrency depends on your language's error-handling patterns, but both require clear propagation rules. Unifying these patterns ensures errors are safely caught and communicated across concurrent processes without crashing the system.

How do I add structured logging and monitoring to existing error-handling patterns?

Add structured logging and monitoring by standardizing your error types and propagation rules within your error-handling patterns. This improves debuggability by ensuring all API and concurrency exceptions are properly logged and tracked for observability across production systems.

Can I apply these cross-language error-handling patterns to concurrent error scenarios?

Yes, you can apply cross-language error-handling patterns to concurrent error scenarios by defining standardized error types and propagation rules. This ensures reliable execution and safe fallbacks across concurrent processes in distributed production environments.