golang-structs-interfaces

Golang struct and interface design patterns — composition, embedding, type assertions, type switches, interface segregation, dependency injection via interfaces, struct field tags, and pointer vs value receivers. Use this skill when designing Go types, defining or implementing interfaces, embedding structs or interfaces, writing type assertions or type switches, adding struct field tags for JSON/YAML/DB serialization, or choosing between pointer and value receivers. Also use when the user asks about "accept interfaces, return structs", compile-time interface checks, or composing small interfaces into larger ones.

Quality

82%

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

65%

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

A well-structured, highly actionable Go type-system reference with executable examples throughout, but it carries some concept-explanation prose Claude doesn't need and is fairly long for a single SKILL.md. Splitting the reference tables and Common Mistakes into a bundled reference file, and trimming basic concept explanations, would push it higher.

Suggestions

Trim prose that re-explains basic concepts Claude already knows (e.g. what embedding promotes, what a type switch does); keep only the Go-specific rule or gotcha.

Move the large reference tables (Key Standard Library Interfaces, Struct Field Tags directives, Common Mistakes) into a bundled reference file (e.g. references/go-type-reference.md) and link from the body, reducing SKILL.md length and improving progressive disclosure.

Add a short, explicitly sequenced workflow for the few multi-step processes (e.g. compile-time interface check → go vet → act on failures) with an explicit validate/retry checkpoint to raise workflow clarity.

Dimension	Reasoning	Score
Conciseness	Mostly lean and accurate, but includes explanatory prose for concepts Claude already knows (e.g. 'Embedding promotes the inner type's methods and fields... composition, not inheritance', 'Discover the dynamic type of an interface value') and is fairly long; it could be tightened, matching the 'mostly efficient but includes some unnecessary explanation' anchor rather than the fully lean anchor.	2 / 3
Actionability	Nearly every section provides fully executable Go code with clear good/bad pairs, plus concrete reference tables (field-tag directives, receiver-choice matrix, stdlib interfaces) — copy-paste ready guidance.	3 / 3
Workflow Clarity	Content is organized as topical pattern sections rather than a sequenced multi-step workflow; while useful checkpoints exist (compile-time interface check, noCopy + go vet), there is no cohesive validate→fix→retry flow, so it sits at the 'steps listed but checkpoints implicit' level.	2 / 3
Progressive Disclosure	No bundle files exist, so all reference material (stdlib interface table, field-tag directive table, large Common Mistakes table) lives inline in the ~365-line SKILL.md; cross-skill '→ See' references are clean and one-level, but content that could be split into separate files is inline, matching the 'some structure, content that should be separate is inline' anchor.	2 / 3
	Total	9 / 12 Passed

Description

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.

A strong description: specific, third-person, with explicit 'what' and 'when' clauses and natural trigger terms. It is clearly scoped to Go struct/interface design and unlikely to conflict with sibling skills.

Dimension	Reasoning	Score
Specificity	Lists many concrete actions — 'composition, embedding, type assertions, type switches, interface segregation, dependency injection via interfaces, struct field tags, and pointer vs value receivers' — matching the 'lists multiple specific concrete actions' anchor.	3 / 3
Completeness	Explicitly states what the skill does (first sentence) and provides explicit 'Use this skill when...' and 'Also use when...' triggers, clearly answering both what and when.	3 / 3
Trigger Term Quality	Covers natural phrases a user would say ('designing Go types', 'defining or implementing interfaces', 'adding struct field tags for JSON/YAML/DB serialization') plus the quoted idiom 'accept interfaces, return structs', giving good coverage of natural terms.	3 / 3
Distinctiveness Conflict Risk	The Go type-system niche with its specific triggers (compile-time interface checks, receiver choice, struct tags) is clearly distinct and unlikely to fire for an unrelated skill.	3 / 3
	Total	12 / 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-structs-interfaces/SKILL.md
Commit: 4158351

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