golang-error-handling
Idiomatic Golang error handling — creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, the single handling rule, structured logging with slog, HTTP request logging middleware, and samber/oops for production errors. Built to make logs usable at scale with log aggregation 3rd-party tools. Apply when creating, wrapping, inspecting, or logging errors in Go code. For samber/oops specifics → See `samber/cc-skills-golang@golang-samber-oops` skill; for slog handler ecosystem → See `samber/cc-skills-golang@golang-samber-slog` skill.
64
78%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/golang-error-handling/SKILL.mdQuality
Discovery
100%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 is an excellent skill description that thoroughly enumerates specific Go error handling capabilities, includes natural trigger terms that developers would use, and explicitly states when to apply the skill. The cross-references to related skills further strengthen distinctiveness by clearly delineating scope boundaries. Minor verbosity could be trimmed, but it doesn't detract from quality.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and concepts: error creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, structured logging with slog, HTTP request logging middleware, and samber/oops. Very comprehensive enumeration of capabilities. | 3 / 3 |
Completeness | Clearly answers both 'what' (idiomatic Go error handling with a detailed list of subtopics) and 'when' ('Apply when creating, wrapping, inspecting, or logging errors in Go code'). Also includes cross-references to related skills, which further clarifies scope boundaries. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms a Go developer would use: 'error handling', 'wrapping', '%w', 'errors.Is', 'errors.As', 'errors.Join', 'sentinel errors', 'panic/recover', 'slog', 'samber/oops', 'Go code', 'Golang'. These are exactly the terms users would mention when seeking help with Go error handling. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — narrowly scoped to Go error handling specifically, with explicit cross-references to related but separate skills (samber/oops and samber/slog). The combination of 'Golang', 'error handling', and specific Go stdlib references makes it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
57%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a well-structured skill with strong progressive disclosure and clear organization across reference files. Its main weakness is the lack of inline executable code examples in the SKILL.md itself — the best practices are stated as rules but the concrete implementations are entirely deferred to reference files. The persona/modes preamble adds some verbosity without proportional value, and workflows lack explicit validation checkpoints.
Suggestions
Add 2-3 minimal executable Go code snippets inline (e.g., wrapping with %w, errors.Is check, slog error logging) so the main file is actionable without requiring reference file access.
Add explicit validation/verification steps to the Audit mode workflow — e.g., 'After sub-agents complete, verify zero remaining violations by grepping for common anti-patterns.'
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The best practices summary is reasonably efficient, but the persona/modes section adds overhead that doesn't directly help Claude handle errors. The 15-point summary is dense but some points overlap with what's in the references. The sub-agent parallelization section and cross-references are useful but the overall document could be tighter. | 2 / 3 |
Actionability | The 15 best practices are specific and prescriptive (e.g., 'use fmt.Errorf("{context}: %w", err)'), which is good. However, the SKILL.md itself contains no executable code examples — all concrete code is deferred to reference files. The summary rules are actionable as guidelines but lack copy-paste-ready snippets in the main file. | 2 / 3 |
Workflow Clarity | The three modes (Coding, Review, Audit) provide workflow structure, and the audit parallelization section gives clear sub-agent assignments. However, there are no explicit validation checkpoints or feedback loops — for example, no 'verify no swallowed errors remain' step after an audit pass. The coding mode mentions an optional background sub-agent but the workflow is loosely defined. | 2 / 3 |
Progressive Disclosure | Excellent structure: a concise overview with 15 numbered rules, then clearly signaled one-level-deep references to three detailed files (error-creation.md, error-wrapping.md, error-handling.md), plus well-organized cross-references to related skills. Each reference link includes a brief description of what it covers, making navigation easy. | 3 / 3 |
Total | 9 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
metadata_field | 'metadata' should map string keys to string values | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Repository
- samber/cc-skills-golang
- Commit
8c7e016
- 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.