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.
Install with Tessl CLI
npx tessl i github:wshobson/agents --skill error-handling-patterns72
Does it follow best practices?
If you maintain this skill, you can automatically optimize it using the tessl CLI to improve its score:
npx tessl skill review --optimize ./path/to/skillAgent success when using this skill
Validation for skill structure
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.
This description has good structure with an explicit 'Use when' clause and covers the error handling domain adequately. However, it relies on somewhat abstract terminology ('Master error handling patterns') rather than concrete actions, and the trigger terms could better match natural user language. The 'when' triggers are slightly too broad, potentially causing conflicts with API design or reliability-focused skills.
Suggestions
Replace abstract phrasing with concrete actions: 'Implement try-catch blocks, design Result/Either types, create error hierarchies, add retry logic' instead of 'Master error handling patterns'.
Add more natural trigger terms users would say: 'try-catch', 'exception handling', 'error codes', 'handle failures', 'crash recovery', 'error messages'.
Narrow the 'Use when' triggers to be more specific to error handling: 'Use when implementing try-catch, designing error types, handling failures, or adding error recovery logic' rather than broad terms like 'designing APIs'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (error handling) and lists some actions/concepts (exceptions, Result types, error propagation, graceful degradation), but 'Master error handling patterns' is somewhat vague and doesn't list concrete actions like 'implement try-catch blocks' or 'convert exceptions to Result types'. | 2 / 3 |
Completeness | Clearly answers both what (error handling patterns including exceptions, Result types, error propagation, graceful degradation) and when (implementing error handling, designing APIs, 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', but misses common user phrases like 'try-catch', 'error codes', 'exception handling', 'crash', 'failure handling', or language-specific terms users might naturally say. | 2 / 3 |
Distinctiveness Conflict Risk | While error handling is a specific domain, 'designing APIs' and 'improving application reliability' are broad triggers that could overlap with API design skills or general code quality skills. The core error handling focus is distinct but the triggers expand scope too broadly. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides excellent actionable code examples across multiple languages with complete, executable implementations of error handling patterns. However, it suffers from being overly comprehensive in a single file, includes some unnecessary conceptual explanations Claude already knows, and lacks clear workflow guidance for when to apply specific patterns. The content would benefit from being split into language-specific reference files with a leaner overview.
Suggestions
Remove or significantly condense the 'Core Concepts' and 'When to Use This Skill' sections - Claude already understands error handling philosophies and can infer appropriate use cases
Add a decision flowchart or clear workflow: 'When implementing error handling: 1. Identify error category → 2. Choose pattern → 3. Implement → 4. Validate with tests'
Split language-specific patterns into separate reference files (e.g., references/python-errors.md, references/typescript-errors.md) and keep only a quick-reference summary in the main skill
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary explanatory content (e.g., 'When to Use This Skill' section, 'Core Concepts' explaining basic error handling philosophies Claude already knows). However, the code examples themselves are efficient and the overall structure avoids excessive verbosity. | 2 / 3 |
Actionability | Provides fully executable, copy-paste ready code examples across multiple languages (Python, TypeScript, Rust, Go). Each pattern includes complete implementations with usage examples, not pseudocode. | 3 / 3 |
Workflow Clarity | While individual patterns are clear, there's no explicit workflow for when to apply which pattern or validation checkpoints. The 'Best Practices' section lists guidelines but doesn't provide a clear decision tree or sequence for implementing error handling in a project. | 2 / 3 |
Progressive Disclosure | References to external files (references/, assets/, scripts/) are listed at the end, but the main content is a monolithic document with extensive inline code. The language-specific sections could be split into separate files with the main skill providing an overview and navigation. | 2 / 3 |
Total | 9 / 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 | |
- 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.