error-handling

Consolidate error handling patterns for UI components, API responses, and form validation.

Updated Dec 17, 2025
One-click install
npx skills add https://github.com/veerababumanyam/RawDrive102 --skill error-handling-veerababumanyam
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling
Source: https://github.com/veerababumanyam/RawDrive102/tree/main/.claude/skills/error-handling
Command: npx skills add https://github.com/veerababumanyam/RawDrive102 --skill error-handling-veerababumanyam

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill consolidates robust error handling patterns for UI components, API responses, and form validation in RawDrive.

Core Features & Use Cases

  • Error boundaries: Implement React ErrorBoundary components to catch rendering errors and present accessible fallbacks.
  • API error schemas: Define consistent backend error structures (error, message, details, request_id) for predictable client handling.
  • User-friendly messaging: Map technical errors to clear, actionable messages for users and support teams.
  • Loading and empty states: Provide consistent loading indicators and empty-state messaging to improve UX during data fetches.
  • Logging & monitoring: Integrate structured logging and error-monitoring (e.g., Sentry) to capture errors with context while avoiding PII.
  • Async error handling: Use try/catch flows, error propagation, and retry strategies in client code.
  • Security considerations: Avoid leaking sensitive information in errors and logs; ensure proper permissions and exposure controls.

Quick Start

Integrate error handling by wrapping major UI sections with ErrorBoundary and mapping API error codes to user-friendly messages using the ERROR_MESSAGES mapping. Add backend exception handlers to return structured error responses and ensure sensitive data is not logged. Use frontend loading and inline error messaging for resilient UX.

Frequently Asked Questions about error-handling

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

FAQPage Schema
How do I implement consistent API error handling schemas for frontend and backend layers?

Consistent API error handling schemas require defining a standardized backend error structure containing error, message, details, and request_id fields. This ensures predictable client handling by mapping technical error codes to user-friendly messages across both frontend and backend layers.

How do React ErrorBoundary components work for catching UI rendering errors?

React ErrorBoundary components work for catching UI rendering errors by wrapping major UI sections to intercept rendering failures and present accessible fallbacks. This mechanism prevents entire application crashes by isolating errors and displaying safe fallback user interfaces.

What's the best way to map technical API errors to clear user-friendly messages?

The best way to map technical API errors to clear user-friendly messages is by implementing an ERROR_MESSAGES mapping structure. This translates backend error codes into actionable text for users and support teams, ensuring consistent communication across the application.

How do I integrate structured logging and error monitoring without exposing PII?

Integrate structured logging and error monitoring by connecting tools like Sentry to capture errors with contextual metadata. Ensure proper security considerations by avoiding sensitive information in logs and enforcing strict permissions and exposure controls to prevent PII leakage.

Does this error handling approach work with both TypeScript and Python?

Yes, this error handling approach works with both TypeScript and Python, providing concrete implementation examples for both languages. It covers frontend UI components and backend API responses, ensuring robust async error handling and standardized schemas across the stack.

What are the limitations of using try/catch flows for async error handling in client code?

Limitations of using try/catch flows for async error handling include managing error propagation complexity and ensuring retry strategies do not overwhelm backend systems. Implementing proper loading and empty states is necessary to maintain UX resilience during these asynchronous failures.