error-handling-patterns
Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability.
71
58%
Does it follow best practices?
Impact
95%
1.39xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./tests/ext_conformance/artifacts/agents-wshobson/developer-essentials/skills/error-handling-patterns/SKILL.mdQuality
Discovery
67%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description adequately covers both what the skill does and when to use it, with an explicit 'Use when' clause. However, the capabilities listed are more like category names than concrete actions, and the trigger terms, while relevant, miss common variations users might naturally use. The cross-cutting nature ('across languages') and broad triggers like 'designing APIs' create some overlap risk with other skills.
Suggestions
Replace abstract pattern names with concrete actions, e.g., 'Implements try-catch blocks, converts exceptions to Result/Either types, adds retry logic with exponential backoff, wraps APIs with proper error responses'.
Expand trigger terms to include common user phrases: 'try-catch', 'error codes', 'retry logic', 'fallback strategy', 'exception safety', 'error boundaries', 'panic handling'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (error handling) and lists some patterns (exceptions, Result types, error propagation, graceful degradation), but these are more category labels than concrete actions. It doesn't specify what concrete actions the skill performs (e.g., 'converts try-catch blocks to Result types', 'adds retry logic'). | 2 / 3 |
Completeness | Clearly answers both 'what' (master error handling patterns including exceptions, Result types, error propagation, graceful degradation) and 'when' (Use when implementing error handling, designing APIs, or improving application reliability) with an explicit 'Use when...' clause. | 3 / 3 |
Trigger Term Quality | Includes relevant terms like 'error handling', 'exceptions', 'Result types', 'error propagation', and 'graceful degradation', which are reasonably natural. However, it misses common user phrases like 'try-catch', 'error codes', 'retry', 'fallback', 'error recovery', 'exception handling', or specific language patterns users might mention. | 2 / 3 |
Distinctiveness Conflict Risk | The focus on error handling patterns is a reasonably distinct niche, but terms like 'designing APIs' and 'application reliability' are broad enough to overlap with API design skills or general software architecture skills. The cross-language nature also makes it less distinct. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
50%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is a comprehensive error handling reference but fails as a SKILL.md by being far too verbose and monolithic. It contains excellent, executable code examples across four languages, but the content belongs in separate reference files rather than inline. The core issue is treating SKILL.md as an exhaustive tutorial rather than a concise overview with progressive disclosure to detailed materials.
Suggestions
Move language-specific patterns (Python, TypeScript, Rust, Go) into separate reference files (e.g., references/python-errors.md) and keep only a brief summary with links in SKILL.md
Remove the 'Core Concepts' section explaining error categories and philosophies—Claude already knows what exceptions, Result types, and recoverable vs unrecoverable errors are
Trim the 'When to Use This Skill' list to 2-3 key triggers instead of 8 items
Add a decision workflow: given a scenario, which pattern to apply, with explicit steps for implementation and validation
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~400+ lines. Explains basic concepts Claude already knows (error categories, what exceptions vs result types are, recoverable vs unrecoverable errors). The 'When to Use This Skill' section lists obvious scenarios. Multiple full implementations across 4 languages is excessive for a SKILL.md that should be an overview pointing to references. | 1 / 3 |
Actionability | All code examples are fully executable and copy-paste ready across Python, TypeScript, Rust, and Go. The circuit breaker, error aggregation, retry decorator, and Result type implementations are complete and concrete. | 3 / 3 |
Workflow Clarity | The best practices section and the process_order example show a reasonable workflow, but there are no explicit validation checkpoints or feedback loops for when to apply which pattern. The skill reads more like a reference catalog than a guided workflow for implementing error handling. | 2 / 3 |
Progressive Disclosure | References to external files exist at the bottom (references/, assets/, scripts/), but the SKILL.md itself is a monolithic wall containing hundreds of lines of inline code that should be split into language-specific reference files. The overview should be concise with pointers to detailed language-specific guides. | 2 / 3 |
Total | 8 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (642 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- Dicklesworthstone/pi_agent_rust
- Commit
6e3d68c
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.