skills.rest
srstomp
srstompCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

error-handling

Standardize typed AppError hierarchies and centralized API error responses.

8|2|Updated Jan 15, 2026
Search Tags:#observability#error-handling#sentry#api-errors#retry-patterns#app-errors#react-errors
One-click install
npx skills add https://github.com/srstomp/pokayokay --skill error-handling-srstomp
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: error-handling
Source: https://github.com/srstomp/pokayokay/tree/main/plugins/pokayokay/skills/error-handling
Command: npx skills add https://github.com/srstomp/pokayokay --skill error-handling-srstomp

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Errors are often implicit and hard to debug across distributed systems; this skill defines a standardized approach to error handling to improve debuggability and reliability.

Core Features & Use Cases

  • Establishes a typed AppError hierarchy with domain-specific errors (ValidationError, NotFoundError, AuthenticationError, etc.).
  • Provides centralized API error response formats and observability integration (Sentry) for visibility.
  • Covers resilience patterns including retries, fallbacks, and circuit breakers to gracefully handle downstream failures.
  • Includes guidance for React error boundaries and user-friendly error messaging to improve UX.

Quick Start

Define a base AppError, create domain-specific errors, and add a centralized error handler with a basic retry fallback.

Frequently Asked Questions about error-handling

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

FAQPage Schema
How do I design resilient error handling for API servers and frontend UIs?▼

Design resilient error handling by standardizing a typed AppError hierarchy, structured API error responses, and centralized handlers to propagate clear error shapes across API servers and frontend UIs.

What is a typed AppError hierarchy and how does it improve observability?▼

A typed AppError hierarchy establishes domain-specific errors like ValidationError and NotFoundError to standardize messages. This improves observability by enabling consistent tracing and Sentry integrations for system failures.

How do I implement retry patterns and circuit breakers for downstream failures?▼

Implement retry patterns and circuit breakers by applying optional recovery logic within centralized error handlers to gracefully handle downstream failures, rate limits, and temporary service disruptions.

Can I use this approach to handle React errors and improve user-facing messaging?▼

Yes, you can use this approach to handle React errors. It includes guidance for React error boundaries and user-friendly error messaging to improve UX when validation or downstream failures occur.

Does this error handling approach work without external dependencies?▼

Yes, the approach works without external dependencies. It defines a base AppError and centralized handler natively, while offering optional observability integrations like Sentry for enhanced tracing.

Related Skills

Explore More Software Engineering Skills→
adelabdelgawadadelabdelgawad

rust-error-handling

Define and propagate typed domain errors across Rust, Leptos, Axum, and SQLx apps.

Community
Advanced
exilonXexilonX

vtex-io-observability-and-ops

Add structured logging and integration metrics to VTEX IO backend services.

Community
Intermediate
1natsu1721natsu172
1

1natsu-error-handling

Implement structured error handling for JavaScript/TypeScript API handlers and middleware.

Community
Advanced
VictorSmaniottoVictorSmaniotto

debug-assistant

Diagnose PHP/Laravel application errors from stack traces and logs.

Community
Intermediate