go-best-practices

Provides Go patterns for type-first development with custom types, interfaces, functional options, and error handling. Must use when reading or writing Go files.

1.10x

Quality

—

Does it follow best practices?

Impact

91%

1.10x

Average score across 3 eval scenarios

Securityby

Passed

No known issues

Quality

Content

65%

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

The body is rich with concrete, executable Go code across types, interfaces, options, errors, logging, and config, making it highly actionable. It is somewhat verbose with redundant justifications and repeated examples, the type-first workflow lacks concrete validation checkpoints, and all content sits in one 265-line file with no progressive disclosure.

Suggestions

Remove trailing justifications that restate what Claude already knows (e.g., 'Panics crash the program', 'This preserves the error chain for debugging', 'Runaway requests cause cascading failures') to tighten conciseness.

Deduplicate examples — exhaustive-switch-with-default-error and error-wrapping each appear in both the pattern sections and the Examples section; keep one canonical version.

Move large reference-style sections (Examples, Configuration) into bundled reference files linked from SKILL.md, and add a concrete validate-then-retry checkpoint to the type-first workflow, to improve progressive disclosure and workflow clarity.

Dimension	Reasoning	Score
Conciseness	The body is mostly lean code, but it pads bullets with restatements of what Claude already knows ('Panics crash the program', 'This preserves the error chain for debugging', 'Runaway requests cause cascading failures') and repeats examples (exhaustive-switch-with-default and error wrapping appear in both pattern and Examples sections).	2 / 3
Actionability	It provides extensive concrete, executable Go code — structs, interfaces, iota enums, functional options, embed, error wrapping, slog logging, and a complete LoadConfig — that is largely copy-paste ready, with only a couple of clearly illustrative '// implementation' stubs.	3 / 3
Workflow Clarity	The type-first workflow is a clear 4-step sequence, but its 'Validate at boundaries' step is an abstract design principle rather than a concrete checkpoint, and there are no feedback loops or error-recovery checkpoints the score-3 anchor expects.	2 / 3
Progressive Disclosure	The body is well-organized into clear sections, but at ~265 lines it is a single monolithic file with no bundled reference files and no one-level-deep references, so nothing is split out for progressive disclosure.	2 / 3
	Total	9 / 12 Passed

Description

75%

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 clearly states both what the skill provides and when to use it, anchored to a distinct Go niche. It lists concrete capability areas but frames them under one 'Provides' verb and offers limited trigger-term variation ('Go files' only).

Suggestions

Replace the single verb 'Provides' with multiple concrete action verbs (e.g., 'Defines custom types, models interfaces, applies functional options, wraps errors') to lift specificity from a topic list to distinct actions.

Add natural trigger variations users actually say — 'Golang', 'Go code', '.go files' — alongside 'Go files' so the description matches how users phrase Go requests.

Dimension	Reasoning	Score
Specificity	It names the domain and several concrete capability areas ('custom types, interfaces, functional options, and error handling'), but frames them under a single 'Provides ... patterns' verb rather than listing multiple distinct concrete actions as the score-3 anchor requires.	2 / 3
Completeness	It explicitly answers both what ('Provides Go patterns for type-first development with custom types, interfaces, functional options, and error handling') and when ('Must use when reading or writing Go files'), satisfying the explicit-trigger requirement that would otherwise cap this at 2.	3 / 3
Trigger Term Quality	It includes the natural term 'Go files' with an explicit 'reading or writing' context, but misses common variations a user would say such as 'Golang', 'Go code', or '.go files', so coverage is partial.	2 / 3
Distinctiveness Conflict Risk	It carves a clear Go-specific niche with a distinct file-type trigger ('reading or writing Go files'), making it unlikely to fire for non-Go skills; the broad within-Go trigger is the only mild overlap risk.	3 / 3
	Total	10 / 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 — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: NeverSight/skills_feed
Commit: ff6a653

Reviewed: 5 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.