error-handling-patterns

Standardize error handling patterns with exceptions, result types, and Polly resilience policies.

Updated Jan 23, 2026
One-click install
npx skills add https://github.com/alexsandrocruz/DominusLeads --skill error-handling-patterns-alexsandrocruz
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling-patterns
Source: https://github.com/alexsandrocruz/DominusLeads/tree/main/backend/Sapienza.Leads/.claude/skills/error-handling-patterns
Command: npx skills add https://github.com/alexsandrocruz/DominusLeads --skill error-handling-patterns-alexsandrocruz

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill standardizes error handling patterns across languages to build resilient applications.

Core Features & Use Cases

  • Patterns for exceptions, result types, and error propagation in .NET, TypeScript, and other platforms.
  • Resilience tooling with Polly, retries, circuit breakers, and graceful degradation for robust APIs and services.
  • Use case: design a fault-tolerant API client that surfaces meaningful errors while retrying transient faults.

Quick Start

Use the error-handling-patterns skill to outline a retry policy in a .NET API using Polly with a fallback.

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 retry policy in a .NET API using Polly?

You can implement a retry policy in a .NET API using Polly by applying resilience tooling to handle transient faults. This skill outlines how to configure retries with a fallback policy to build fault-tolerant API clients that surface meaningful errors.

What is the difference between using exceptions and result types for error handling?

Exceptions and result types differ in how they signal errors during execution. This skill standardizes patterns for both structured exception hierarchies and result-based error signaling across .NET, TypeScript, and other platforms for resilient applications.

When should I use a circuit breaker pattern in my service integration?

You should use a circuit breaker pattern in service integration to prevent cascading failures during outages. This skill covers applying resilience tooling, including circuit breakers and graceful degradation, to build robust APIs and client-facing code.

Can I use this error-handling patterns skill for TypeScript applications?

Yes, you can use this skill for TypeScript applications. It standardizes error handling patterns for exceptions, result types, and error propagation across .NET, TypeScript, and other platforms to build resilient applications.

What is the best way to design a fault-tolerant API client that handles transient faults?

The best way to design a fault-tolerant API client is to combine resilience tooling with meaningful error surfacing. This skill outlines how to use Polly policies, including retries and circuit breakers, to gracefully degrade and handle transient faults.

Why does my error propagation strategy fail across different language platforms?

Error propagation strategies often fail across platforms due to inconsistent exception hierarchies and error signaling. This skill standardizes error handling patterns across languages to satisfy requirements for structured exceptions and result types.