error-handling

Implement React error boundaries, OpenTelemetry tracing, and GraphQL error policies.

3|Updated Dec 30, 2025
One-click install
npx skills add https://github.com/guicheffer/devorch-cli --skill error-handling-guicheffer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling
Source: https://github.com/guicheffer/devorch-cli/tree/main/templates/skills/observability/error-handling
Command: npx skills add https://github.com/guicheffer/devorch-cli --skill error-handling-guicheffer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides comprehensive strategies and patterns for handling errors gracefully in applications, preventing crashes, and ensuring a smooth user experience even when unexpected issues arise.

Core Features & Use Cases

  • Error Isolation: Implement ErrorBoundary components to catch and manage errors within specific parts of your application, preventing them from cascading and crashing the entire UI.
  • Observability: Integrate with OpenTelemetry to automatically record exceptions, create spans for error events, and provide detailed context for debugging in distributed tracing systems.
  • User Recovery: Design user-friendly fallback UIs that inform users about errors and offer actionable recovery steps, such as retrying an operation or navigating to a safe state.
  • GraphQL Error Management: Configure errorPolicy for GraphQL queries to handle partial data and specific error types gracefully.
  • Retry Strategies: Implement automatic retries with exponential backoff for transient network issues.
  • Use Case: When a network request fails, this Skill ensures the user sees a helpful message with a "Try Again" button instead of a blank screen, while simultaneously logging the error with full context to your observability platform.

Quick Start

Wrap your main application component with the ErrorBoundary to catch any unhandled errors.

Frequently Asked Questions about error-handling

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement React error boundaries to isolate component failures and prevent UI crashes?

React error boundaries isolate component failures by catching errors within specific application parts, preventing them from crashing the entire UI. Wrap your main application component with an ErrorBoundary to manage unhandled errors gracefully.

How do I integrate OpenTelemetry to trace exceptions in my application?

Integrate OpenTelemetry to trace exceptions by automatically recording errors and creating spans for error events. This provides detailed context for debugging distributed tracing systems when unexpected application issues arise.

What is the best way to handle GraphQL errors and manage partial data responses?

The best way to handle GraphQL errors is configuring specific errorPolicy settings on your GraphQL client. This manages partial data and specific error types gracefully, ensuring queries fail without breaking the entire application state.

How do I implement retry logic with exponential backoff for transient network issues?

Implement retry logic for transient network issues using automatic retries with exponential backoff strategies. This approach sequentially repeats failed network requests, gradually increasing wait times to recover transient failures without overwhelming the server.

Does this error handling approach work with custom fallback UIs for user recovery?

Yes, this error handling approach works with custom fallback UIs for user recovery. It designs user-friendly interfaces that inform users about errors and offer actionable recovery steps, like retrying an operation or navigating to a safe state.

When should I use error boundaries instead of standard try-catch blocks for UI rendering?

Use error boundaries instead of standard try-catch blocks when you need to isolate UI rendering failures and display fallback UIs. Try-catch blocks handle logic errors, but error boundaries specifically prevent component tree crashes.