Name: golang-error-handling
Rating: 68 (1 reviews)
Author: samber

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.

Quality

83%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Quality

Content

78%Weight 40%Scale 1-5

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

A well-structured, concise overview that delegates detail to real reference files and lays out clear coding/review/audit workflows. Its main gap is the absence of inline executable code examples and explicit validation feedback loops in the workflow steps.

Suggestions

Add one or two short, complete inline code blocks for the most common cases (e.g. a wrapped error return and a single-handling-rule log-or-return) so the body is actionable without opening a reference.

Make the validation/feedback loop explicit in audit and review modes — e.g. 'consolidate findings, then re-run the violating sub-agent to confirm fixes' — to strengthen workflow_clarity.

Tighten the low-cardinality logging rule (item 15) and the Detailed Reference blurbs to reduce overlap with the summary list.

Dimension	Reasoning	Score
Conciseness	The body is lean and assumes Claude's competence — 15 terse best-practice rules plus mode definitions with no padding about what errors are — though rules like the low-cardinality logging note and the duplicated detail in the reference blurbs could be tightened slightly.	4 / 5
Actionability	Concrete, specific guidance with real executable patterns ('fmt.Errorf("{context}: %w", err)', 'errors.Is', 'errors.AsType[T](err)', 'errors.Join', 'slog'), but the body contains no complete copy-paste code blocks — those are delegated to the reference files, leaving a minor gap.	4 / 5
Workflow Clarity	Three modes are clearly sequenced (coding follows best practices sequentially with an optional violation-grep sub-agent; review is diff-focused and sequential; audit fans out 5 named category sub-agents), but explicit validate→fix→retry feedback checkpoints are only implied rather than stated.	4 / 5
Progressive Disclosure	A clear overview with well-signaled, one-level-deep references to three real files (error-creation.md, error-wrapping.md, error-handling.md) plus a cross-references section and external links — content is appropriately split and easy to navigate.	5 / 5
	Total	17 / 20 Passed

Description

88%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong, specific description that clearly states what the skill does and when to apply it, using third-person voice with concrete Go error-handling triggers. It could broaden natural-language synonyms and file-extension cues to fully maximize trigger discoverability.

Suggestions

Add common synonyms and a file cue to the trigger clause, e.g. 'Apply when creating, wrapping, inspecting, or logging errors in Go (.go) code, or when the user mentions Go error handling or error wrapping.'

Consider trimming the long enumeration slightly so the trigger phrase stands out more for rapid scanning.

Dimension	Reasoning	Score
Specificity	Lists many concrete capabilities — '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' — giving comprehensive, specific coverage rather than vague language.	5 / 5
Completeness	Explicitly answers both 'what' (the enumerated error-handling capabilities) and 'when' via the concrete trigger clause 'Apply when creating, wrapping, inspecting, or logging errors in Go code.'	5 / 5
Trigger Term Quality	Includes natural terms a user would say ('error handling', 'wrapping', 'logging errors', 'Go code') in the 'Apply when creating, wrapping, inspecting, or logging errors' clause, but lacks file-extension synonyms (e.g. .go) and a few common phrasings, stopping short of comprehensive.	4 / 5
Distinctiveness Conflict Risk	Occupies a clear Go-error-handling niche with distinct triggers, but explicitly overlaps and delegates to closely related sibling skills (samber-oops, samber-slog), leaving minor overlap risk.	4 / 5
	Total	18 / 20 Passed

Validation

87%

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 — 14 / 16 Passed

Validation for skill structure

Criteria	Description	Result
metadata_field	'metadata' should map string keys to string values	Warning
relative_links	Relative link issues: 1 missing	Warning

	Total	14 / 16 Passed

Repository: samber/cc-skills-golang
Path: skills/golang-error-handling/SKILL.md
Commit: 19a0626

Reviewed: 1 day ago

Table of Contents

Discovery Implementation Validation

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.