error-handling

Enforce typed error taxonomies, propagation, retry policies, and exit codes across codebases.

Updated May 28, 2026
One-click install
npx skills add https://github.com/syntropic137/harness-app-template --skill error-handling-syntropic137
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-handling
Source: https://github.com/syntropic137/harness-app-template/tree/main/.claude/skills/error-handling
Command: npx skills add https://github.com/syntropic137/harness-app-template --skill error-handling-syntropic137

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Inconsistent, poorly designed error handling leads to silent failures, unactionable error messages, and time-consuming production debugging, as errors are often swallowed, stringly typed, or lack context for callers and operators to respond appropriately.

Core Features & Use Cases

  • Typed Error Taxonomies: Define named error types (e.g. NotFoundError, TransientUpstreamError) so callers can dispatch on failure modes without parsing error strings.
  • Propagation & Cause Preservation: Enforce deliberate error flow and preserve cause chains to maintain debugging context across system boundaries.
  • Retry & Exit Code Standards: Guide bounded, jittered retry policies for idempotent operations and distinct exit codes for CLI tools to enable reliable CI dispatch.
  • Use Case: For a polyglot team building Rust backend services, TypeScript frontends, and Python automation scripts, use this skill to align all codebases on a consistent error model, reducing mean time to resolve production incidents and eliminating brittle CI error handling.

Quick Start

Use the error-handling skill to audit your project's error propagation, retry policies, and exit code conventions for consistency and safety.

Frequently Asked Questions about error-handling

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

FAQPage Schema
How do I standardize error handling across a polyglot codebase with Rust, TypeScript, Python, and Go?

To standardize error handling across polyglot codebases, enforce typed error taxonomies and deliberate error propagation, eliminating silent failures and unactionable error messages across Rust, TypeScript, Python, and Go environments.

What are typed error taxonomies and how do they improve production debugging?

Typed error taxonomies define named error types like NotFoundError or TransientUpstreamError so callers can dispatch on failure modes without parsing strings. This preserves cause chains across system boundaries to maintain debugging context during production incidents.

How do I implement bounded retry policies with backoff and jitter for idempotent operations?

Implement bounded retry policies with backoff and jitter by enforcing deliberate error flow standards for idempotent operations. This ensures transient failures are handled systematically without overwhelming upstream services or causing brittle production workflows.

Does this approach work for standardizing CLI tool exit codes in CI pipelines?

Yes, this approach works for CLI tools by defining distinct exit code standards that enable reliable CI dispatch. It prevents swallowed errors and stringly typed messages, allowing CI pipelines to correctly interpret and route execution failures.

Why do silent failures and stringly typed errors make production debugging difficult?

Silent failures and stringly typed errors make production debugging difficult because they lack context for callers and operators to respond appropriately. Without typed error taxonomies and cause chain preservation, errors are swallowed and fail to provide actionable debugging information.

Can I use this error handling model for distributed services and frontend applications?

Yes, you can use this error handling model for distributed services and frontend applications. It applies structured error logging at system boundaries, aligning backend services and frontends on a consistent error model to reduce mean time to resolve incidents.