m13-domain-error

Design domain error categorization, recovery policies, and hierarchy definitions for software systems.

1|Updated Apr 4, 2026
One-click install
npx skills add https://github.com/Jylhis/claude-marketplace --skill m13-domain-error-jylhis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: m13-domain-error
Source: https://github.com/Jylhis/claude-marketplace/tree/main/plugins/rust-dev/skills/m13-domain-error
Command: npx skills add https://github.com/Jylhis/claude-marketplace --skill m13-domain-error-jylhis

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Developers need a systematic approach to design and implement domain error handling that balances user experience, debugging, and resilience. This skill guides the creation of error categories, recovery strategies, and context-aware error definitions.

Core Features & Use Cases

  • Error Categorization: Defines user-facing, internal, system, transient, and permanent error types.
  • Recovery Strategies: Offers patterns such as retry with backoff, fallback defaults, circuit breakers, and timeout handling.
  • Implementation Guidance: Provides references to Rust crates like thiserror, anyhow, and retry libraries, and maps design decisions to concrete code examples.
  • Use Case Example: Designing error handling for a payment service, including retry policies, user messages, and compliance logging.

Quick Start

Use the m13-domain-error skill to generate a domain error categorization guide for a payment processing system.

Frequently Asked Questions about m13-domain-error

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

FAQPage Schema
What is domain error categorization and why do I need it for resilient applications?

Domain error categorization classifies errors into user-facing, internal, system, transient, and permanent types to balance user experience, debugging, and resilience. It guides recovery policies by distinguishing recoverable transient failures from permanent system faults.

How do I design a retry strategy with backoff and circuit breakers in Rust?

Design a retry strategy by applying backoff patterns, fallback defaults, and circuit breakers to handle transient errors. In Rust, map these design decisions to concrete code using crates like thiserror, anyhow, and dedicated retry libraries for resilient execution.

What's the best way to structure error handling for a payment processing service?

The best way to structure error handling for a payment service is defining domain error categories, recovery strategies, and contextual error information. This includes retry policies, user-facing messages, and compliance logging to ensure robust transaction processing.

When should I use circuit breaker patterns instead of simple retry mechanisms?

Use circuit breaker patterns instead of simple retries when system errors indicate sustained downstream failures. Categorize errors as transient or permanent first; apply retry with backoff for transient issues, but trigger circuit breakers to prevent cascading system failures.

Does this error handling approach work with Rust crates like thiserror and anyhow?

Yes, this approach works with Rust crates like thiserror and anyhow. It provides implementation guidance that maps domain error categorization and recovery strategies directly to concrete code examples using these libraries and retry mechanisms.

How do I add contextual information to domain errors for better debugging?

Add contextual information to domain errors by defining context-aware error types across user-facing, internal, and system categories. This systematic approach ensures errors carry sufficient debugging context while maintaining appropriate user-facing messages and recovery policies.