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.

1.07x

Quality

76%

Does it follow best practices?

Impact

97%

1.07x

Average score across 3 eval scenarios

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

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

The canonical home for this skill is golang-error-handling in samber/cc-skills-golang

Quality

Content

65%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, lean overview that exemplifies progressive disclosure by pointing to real one-level-deep reference files. It is weaker on standalone actionability (no full code blocks in the body) and workflow validation (no explicit verification or synthesis checkpoints).

Suggestions

Add one compact, copy-paste-ready code block per common case (error wrapping with %w, an errors.Is/As inspection, a slog error log) directly in the body so the skill is executable without opening the references.

Insert an explicit validation checkpoint in the workflows — e.g. a 'Verify: run golangci-lint on changed files' step in coding mode and a synthesis step that aggregates the five audit sub-agents' findings in audit mode.

Trim the redundancy between the 15-item best-practices summary and the audit sub-agent task descriptions so each sub-agent line references a summary item instead of restating it.

Dimension	Reasoning	Score
Conciseness	The body is a lean overview that assumes Claude's competence and avoids explaining known concepts, but the five audit sub-agent descriptions restate rules already in the 15-item summary and the reference blurbs preview reference content, leaving minor trimmable redundancy short of a 5.	4 / 5
Actionability	Concrete inline patterns appear (e.g. `fmt.Errorf("{context}: %w", err)` and named functions like errors.Is/As/Join and slog), but the body contains no complete executable code blocks — full examples for the common cases are deferred to the reference files, leaving key details missing.	3 / 5
Workflow Clarity	Coding/Review/Audit modes give a clear sequence and the audit mode breaks work into five parallel sub-agents, but there are no explicit validation checkpoints (no 'verify with golangci-lint' step, no synthesis step after the parallel audit), so checkpoints are implicit rather than present.	3 / 5
Progressive Disclosure	The body is a clear overview with well-signaled one-level-deep references to error-creation.md, error-wrapping.md, and error-handling.md (all real files in ./references/), with descriptive labels and easy navigation — textbook progressive disclosure.	5 / 5
	Total	15 / 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, comprehensive description that clearly answers both what the skill does and when to apply it, with concrete capabilities rather than vague fluff. Its only weak point is heavy reliance on technical jargon over natural user phrasing and minor overlap with sibling observability skills.

Dimension	Reasoning	Score
Specificity	The description enumerates 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 coverage rather than the minor gaps of a 4.	5 / 5
Completeness	It explicitly states both what the skill does (the enumerated error-handling capabilities plus 'Built to make logs usable at scale') and when to use it via the concrete trigger clause 'Apply when creating, wrapping, inspecting, or logging errors in Go code.'	5 / 5
Trigger Term Quality	Natural phrases like 'Golang error handling', 'errors', 'logging errors in Go code' are present, but the list leans on technical jargon (errors.Is/As, samber/oops) and lacks synonyms or extensions, so it stops short of the comprehensive 5.	4 / 5
Distinctiveness Conflict Risk	Go error handling is a clear niche, but the description extends into 'structured logging with slog, HTTP request logging middleware' which overlaps the observability/samber-oops sibling skills, creating minor overlap risk rather than the minimal risk of a 5.	4 / 5
	Total	18 / 20 Passed

Validation

93%

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

Validation for skill structure

Criteria	Description	Result
metadata_field	'metadata' should map string keys to string values	Warning

	Total	15 / 16 Passed

Repository: Vonage/cloud-runtime-cli
Path: .agents/skills/golang-error-handling/SKILL.md
Commit: f4b9df0

Reviewed: 3 days 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.