error-handling

Implement consistent error handling across the application. Use when adding try-catch blocks, error boundaries, or custom error classes.

⭐21stars🔀15forks📁View on GitHub🕐Updated Jan 7, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill facilitates the implementation of a robust, standardized error-handling framework across the entire application stack. By providing templates for custom error classes, centralized middleware, and frontend error boundaries, it ensures consistent error reporting, improves system resilience, and simplifies the debugging process for developers.

Use Cases

  • Backend API Standardization: Implementing custom error classes and centralized middleware to ensure all API responses follow a consistent JSON error structure (e.g., code, message, status).
  • Frontend UI Stability: Deploying React Error Boundaries and asynchronous fetch wrappers to catch runtime exceptions and prevent application crashes, providing a graceful fallback UI for users.
  • System Observability and Logging: Establishing clear logging guidelines (Error, Warn, Info, Debug) to streamline incident response and improve the quality of logs for monitoring tools.
nameerror-handling
descriptionImplement consistent error handling across the application.

Error Handling Skill

Purpose

Ensure consistent, informative error handling.

Backend Error Handling

Reference: patterns/backend-errors.md

Custom Error Classes

// templates/error-class.ts
export class AppError extends Error {
  constructor(
    public code: string,
    message: string,
    public statusCode: number = 500,
    public details?: unknown
  ) {
    super(message);
    this.name = 'AppError';
  }
}

export class ValidationError extends AppError {
  constructor(message: string, details?: unknown) {
    super('VALIDATION_ERROR', message, 400, details);
  }
}

export class NotFoundError extends AppError {
  constructor(resource: string) {
    super('NOT_FOUND', `${resource} not found`, 404);
  }
}

Error Handler Middleware

function errorHandler(err, req, res, next) {
  logger.error(err);

  if (err instanceof AppError) {
    return res.status(err.statusCode).json({
      error: {
        code: err.code,
        message: err.message,
        details: err.details
      }
    });
  }

  return res.status(500).json({
    error: {
      code: 'INTERNAL_ERROR',
      message: 'An unexpected error occurred'
    }
  });
}

Frontend Error Handling

Reference: patterns/frontend-errors.md

Error Boundaries

class ErrorBoundary extends React.Component {
  state = { hasError: false };

  static getDerivedStateFromError() {
    return { hasError: true };
  }

  componentDidCatch(error, info) {
    logError(error, info);
  }

  render() {
    if (this.state.hasError) {
      return <ErrorFallback onReset={() => this.setState({ hasError: false })} />;
    }
    return this.props.children;
  }
}

Async Error Handling

async function fetchWithError<T>(url: string): Promise<T> {
  const response = await fetch(url);

  if (!response.ok) {
    const error = await response.json();
    throw new ApiError(error.code, error.message);
  }

  return response.json();
}

Logging Guidelines

Level Use For
error Exceptions, failures
warn Recoverable issues
info Important events
debug Development info