Name: jbvc/error-handling-patterns
Rating: 44 (1 reviews)
Author: jbvc

jbvc/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.

Quality

55%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Quality

Content

22%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill is essentially a hollow wrapper that defers all substantive content to an external resource file. The instructions section contains only generic, non-actionable platitudes that could apply to any skill. There are no concrete examples, code snippets, patterns, or specific guidance about error handling in the main file.

Suggestions

Add at least 2-3 concrete, executable code examples of core error handling patterns (e.g., Result types, exception hierarchies, retry logic) directly in the SKILL.md rather than deferring everything to the resource file.

Replace the generic instructions ('Apply relevant best practices and validate outcomes') with specific, actionable guidance such as 'Use custom exception hierarchies for domain errors' or 'Wrap external API calls in retry logic with exponential backoff'.

Add a clear workflow for implementing error handling in a new feature, with explicit steps like: 1) Identify failure modes, 2) Choose error strategy, 3) Implement with specific pattern, 4) Verify error paths with tests.

Remove the 'Do not use this skill when' section as it adds no value, and trim the 'Use this skill when' list to focus on the most important 2-3 triggers.

Dimension	Reasoning	Score
Conciseness	The content is relatively short but includes filler sections like 'Use this skill when' and 'Do not use this skill when' that add little value for Claude. The instructions are generic platitudes ('Clarify goals, constraints, and required inputs') rather than substantive guidance.	2 / 3
Actionability	The instructions are entirely vague and abstract — 'Apply relevant best practices and validate outcomes' provides zero concrete guidance. There are no code examples, no specific commands, no patterns, and no executable content. Everything meaningful is deferred to an external file.	1 / 3
Workflow Clarity	The four bullet points in Instructions are generic meta-instructions that could apply to any skill. There is no clear workflow, no sequencing of steps for error handling implementation, and no validation checkpoints.	1 / 3
Progressive Disclosure	There is a reference to a resource file (resources/implementation-playbook.md) which is one level deep and clearly signaled. However, the SKILL.md itself contains almost no substantive overview content — it's essentially an empty shell pointing to another file, which undermines the purpose of progressive disclosure.	2 / 3
	Total	6 / 12 Passed

Description

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 is structurally sound with a clear 'Use when...' clause and covers the domain adequately. However, it reads more like a course catalog entry than an actionable skill description—it names pattern categories rather than concrete actions Claude would perform. The trigger terms are decent but could be more comprehensive with common user vocabulary.

Suggestions

Replace abstract pattern names with concrete actions, e.g., 'Converts try/catch blocks to Result types, adds retry logic with exponential backoff, implements circuit breakers, and wraps APIs with consistent error responses.'

Expand trigger terms to include natural user phrases like 'try/catch', 'error codes', 'retry logic', 'crash handling', 'failure recovery', and specific language mentions (Rust Result, Python exceptions, Go error returns).

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 it actually does with these patterns (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', 'crash', 'bug', 'failure handling', or specific language patterns.	2 / 3
Distinctiveness Conflict Risk	The error handling focus is somewhat specific, but terms like 'designing APIs' and 'improving application reliability' are broad enough to overlap with API design skills or general code quality/resilience skills. The cross-language scope also makes it less distinct.	2 / 3
	Total	9 / 12 Passed

Validation

100%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 11 / 11 Passed

Validation for skill structure

No warnings or errors.

Reviewed

3 months ago

Table of Contents

Discovery Implementation Validation