error-handling

name	error-handling
description	Error handling patterns, retry strategies, circuit breakers, graceful degradation, and user-facing error communication
layer	utility
category	development
triggers	["error handling","retry strategy","circuit breaker","graceful degradation","error boundary","fault tolerance","exception handling"]
inputs	[{"error_context":"Where and how errors occur (API, database, UI, third-party service)"},{"reliability_requirement":"How critical is this operation (best-effort vs. must-succeed)"},{"user_impact":"How errors affect the end user"}]
outputs	[{"error_strategy":"Comprehensive error handling approach"},{"retry_policy":"When and how to retry failed operations"},{"fallback_plan":"Degradation path when retries are exhausted"},{"error_types":"Typed error hierarchy for the system"},{"user_communication":"How to present errors to users"}]
linksTo	["logging","api-designer","ui-ux-pro"]
linkedFrom	["orchestrator","planner","code-architect"]
preferredNextSkills	["logging","api-designer"]
fallbackSkills	["sequential-thinking"]
riskLevel	low
memoryReadPolicy	selective
memoryWritePolicy	selective
sideEffects	[]

Error Handling

Purpose

This skill provides systematic approaches to handling errors across the entire stack — from database operations through API layers to user interfaces. It covers error classification, retry strategies, circuit breakers, graceful degradation, and the critical art of communicating errors to users without exposing internal details.

Key Concepts

Error Classification

Every error falls into one of these categories, and each demands a different response:

TRANSIENT (retry-safe):
  - Network timeout
  - Database connection pool exhaustion
  - Rate limit (429)
  - Service temporarily unavailable (503)
  - DNS resolution failure
  RESPONSE: Retry with exponential backoff

PERMANENT (do NOT retry):
  - Validation error (400)
  - Authentication failure (401)
  - Authorization failure (403)
  - Resource not found (404)
  - Business rule violation (409/422)
  RESPONSE: Return error to caller immediately

BUG (should never happen in production):
  - Null pointer / undefined access
  - Type mismatch
  - Assertion failure
  - Out of bounds
  RESPONSE: Log with full context, alert, return 500

CATASTROPHIC (system-level):
  - Out of memory
  - Disk full
  - Cascading failure
  - Data corruption
  RESPONSE: Alert immediately, activate fallback, page on-call

The Error Handling Hierarchy

LEVEL 1 — PREVENT: Design errors out of the system
  - Type safety (TypeScript strict mode)
  - Input validation at boundaries
  - Database constraints (NOT NULL, UNIQUE, FK, CHECK)
  - Compile-time checks over runtime checks

LEVEL 2 — DETECT: Catch errors as close to the source as possible
  - Try/catch at integration boundaries
  - Error boundaries in React components
  - Health checks for dependencies
  - Schema validation at API entry points

LEVEL 3 — RECOVER: Automatically recover when possible
  - Retry transient failures
  - Fall back to cached data
  - Degrade gracefully (show partial results)
  - Redirect to alternative service

LEVEL 4 — REPORT: Make errors visible and actionable
  - Structured logging with context
  - Error tracking (Sentry, Datadog)
  - Alerting for critical errors
  - User-facing error messages

LEVEL 5 — LEARN: Prevent recurrence
  - Post-incident reviews
  - Automated tests for discovered bugs
  - Monitoring improvements
  - Runbook updates

Patterns

Pattern 1: Result Type (Errors as Values)

Instead of throwing exceptions, return errors as values:

// Define a Result type
type Result<T, E = Error> =
  | { ok: true; data: T }
  | { : ; : E };


  (): <<, >> {
  
   validation = (input);
   (!validation.) {
     { : , : { : , : validation. } };
  }

  
   available =  (input.);
   (!available.) {
     { : , : { : , : available. } };
  }

  
   {
     order =  db..({ : input });
     { : , : order };
  }  (err) {
     ((err)) {
       { : , : { : , :  } };
    }
     err; 
  }
}


 result =  (input);
 (!result.) {
   (result..) {
     :
       res.().({ : result. });
     :
       res.().({ : result. });
     :
       res.().({ : result. });
  }
}
 res.().(result.);