Name: golang-error-handling
Rating: 64.8 (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

78%

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

Fix and improve this skill with Tessl

tessl review fix ./skills/golang-error-handling/SKILL.md

Quality

Content

72%

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

Well-structured, lean content with excellent progressive disclosure and concrete rule-level guidance. The main gaps are the absence of inline executable code examples and lack of explicit validation checkpoints in the workflow steps.

Suggestions

Add at least one short, complete inline code block in the body (e.g., a canonical wrap-and-inspect snippet) so the skill is copy-paste actionable without opening references.

Insert an explicit validation checkpoint into the audit/review modes (e.g., 'after each sub-agent run, consolidate findings and re-scan for missed log-and-return pairs') to close the workflow-clarity gap.

Dimension	Reasoning	Score
Conciseness	The body is lean and rule-based (e.g., 'Errors MUST be wrapped with context using fmt.Errorf("{context}: %w", err)'), assumes Claude's knowledge of Go, and avoids explaining basic concepts, matching the 'lean and efficient; every token earns its place' anchor rather than the padded score-2 level.	3 / 3
Actionability	Rules are concrete and largely copy-paste-ready (specific verbs, Go versions 1.20+/1.21+/1.26+, exact wrap format), but the body itself contains no complete executable code blocks — those are deferred to the reference files — placing it at 'some concrete guidance but incomplete' rather than 'fully executable code/commands'.	2 / 3
Workflow Clarity	The three modes (Coding/Review/Audit) and the five enumerated audit sub-agents give a clear sequence, but there are no explicit validation/feedback-loop checkpoints (validate -> fix -> retry), so it sits at 'steps listed but checkpoints missing or implicit' rather than the checkpoint-rich score-3 level.	2 / 3
Progressive Disclosure	A concise summary overview points to three well-signaled, one-level-deep reference files (error-creation.md, error-wrapping.md, error-handling.md), all of which exist and are accurately linked, with external links and sibling-skill cross-references kept separate — matching the 'clear overview with well-signaled one-level-deep references' anchor.	3 / 3
	Total	10 / 12 Passed

Description

85%

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 with explicit 'Apply when' trigger guidance and good conflict avoidance via cross-skill deferral. Its main weakness is jargon-heavy phrasing that slightly under-serves natural trigger terms a less technical user might say.

Suggestions

Add a few plain-language trigger phrases (e.g., 'Go panics', 'Go logging', 'Go error messages') alongside the library jargon to broaden natural-term coverage.

Consider trimming the long inline capability enumeration slightly so the 'Apply when' clause is more visually prominent.

Dimension	Reasoning	Score
Specificity	Lists many concrete actions (creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, single handling rule, slog logging, HTTP middleware, samber/oops), matching the 'lists multiple specific concrete actions' anchor rather than the partial 'domain and some actions' level.	3 / 3
Completeness	Explicitly states both what it does (the long capability list) and when to use it ('Apply when creating, wrapping, inspecting, or logging errors in Go code'), satisfying the 'clearly answers both what AND when' anchor; the missing-when cap does not apply.	3 / 3
Trigger Term Quality	Natural terms like 'error handling', 'wrapping', 'logging errors in Go code' are present, but the description leans heavily on library/API jargon (errors.Is/As, errors.Join, samber/oops, %w, slog) and misses some plain phrasings a user might say, so it sits at 'some relevant keywords but missing common variations' rather than full coverage.	2 / 3
Distinctiveness Conflict Risk	It carves a clear Go-error-handling niche and explicitly defers overlapping topics to sibling skills (samber/oops -> golang-samber-oops, slog -> golang-samber-slog), so it is unlikely to trigger for the wrong skill.	3 / 3
	Total	11 / 12 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: 4158351

Reviewed: about 12 hours 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.