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.
75
54%
Does it follow best practices?
Impact
88%
1.29xAverage score across 6 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/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 has good structural completeness with an explicit 'Use when' clause and covers the domain adequately. However, it leans toward listing abstract pattern categories rather than concrete actions the skill performs, and its trigger terms could be expanded to cover more natural user language. The cross-language framing and broad use cases like 'designing APIs' reduce its distinctiveness.
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, and designs error hierarchies'.
Add more natural trigger terms users would say, such as 'try-catch', 'error codes', 'crash handling', 'retry logic', 'fallback', '.unwrap()', 'panic', 'throw/catch'.
Narrow the 'Use when' clause to reduce overlap with API design skills, e.g., 'Use when implementing error handling strategies, adding try-catch blocks, converting between error types, or making code more fault-tolerant'.
| 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., 'wrap functions in try-catch blocks', 'convert exceptions to Result types', 'add retry logic'). | 2 / 3 |
Completeness | Clearly answers both 'what' (error handling patterns including exceptions, Result types, error propagation, graceful degradation) and 'when' with an explicit 'Use when' clause covering implementing error handling, designing APIs, or improving application reliability. | 3 / 3 |
Trigger Term Quality | Includes some relevant keywords like 'error handling', 'exceptions', 'Result types', 'error propagation', and 'graceful degradation'. However, it misses common natural user terms like 'try-catch', 'error codes', 'retry', 'fallback', 'crash', 'bug', 'failure handling', 'robust code', or specific language patterns users might mention. | 2 / 3 |
Distinctiveness Conflict Risk | The error handling focus provides some distinctiveness, but phrases like 'designing APIs' and 'improving application reliability' are broad enough to overlap with API design skills or general code quality/resilience skills. The 'across languages' framing also makes it less distinct. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
42%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 reference document with high-quality, executable code examples across multiple languages, but it severely violates conciseness by explaining concepts Claude already knows and inlining everything into one massive file. The content reads more like a tutorial or textbook chapter than a focused skill instruction, and the lack of any progressive disclosure structure means it consumes excessive context window space for any single use case.
Suggestions
Remove the 'Core Concepts' section entirely (error categories, philosophies) — Claude already knows these distinctions. Start directly with the language-specific patterns.
Split language-specific patterns into separate referenced files (e.g., python-errors.md, typescript-errors.md, rust-errors.md, go-errors.md) and keep SKILL.md as a concise overview with navigation links.
Remove the 'When to Use This Skill' and 'Common Pitfalls' sections — these are basic knowledge Claude already possesses and add no actionable value.
Add a brief decision workflow at the top: given a scenario (API design, batch processing, distributed system), which pattern to apply and in what order, with validation checkpoints.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~400+ lines. Explains basic concepts Claude already knows (error categories, what exceptions are, what Result types are), lists obvious 'when to use' scenarios, and includes extensive boilerplate across four languages. The 'Core Concepts' section explaining recoverable vs unrecoverable errors and error handling philosophies is unnecessary padding. Best practices like 'don't swallow errors' and 'meaningful messages' are things Claude already knows. | 1 / 3 |
Actionability | All code examples are fully executable and copy-paste ready across Python, TypeScript, Rust, and Go. The custom exception hierarchies, retry decorator, circuit breaker, error aggregation, and graceful degradation patterns are all complete, runnable implementations with usage examples. | 3 / 3 |
Workflow Clarity | The skill presents patterns clearly but lacks explicit workflow sequencing for when/how to apply these patterns in a real implementation. There are no validation checkpoints or decision trees for choosing between patterns. The 'Best Practices' section is a flat list rather than a guided workflow. For a skill about error handling in potentially destructive operations, the absence of verification steps is notable. | 2 / 3 |
Progressive Disclosure | Monolithic wall of content with no references to external files. All four language-specific patterns, three universal patterns, best practices, and common pitfalls are inlined in a single massive document. This would benefit enormously from splitting language-specific patterns into separate files and keeping SKILL.md as a concise overview with navigation links. | 1 / 3 |
Total | 7 / 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 (633 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
112197c
Table of Contents
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.