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

86%

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

76%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 high-quality, actionable Go type-design reference with strong code examples and tables. Its main gaps are the absence of any multi-step workflow with validation checkpoints and a few spots of over-explanation.

Suggestions

Trim concepts Claude already knows (e.g., the embedding/zero-value semantics and the Go Proverbs quotes) and remove the redundant ReadWriter vs ReadWriteCloser composition example to tighten conciseness.

If the skill ever guides a multi-step or batch operation (e.g., refactoring receivers across a package), add an explicit validate-then-proceed sequence with a feedback loop so workflow_clarity can rise above 3.

Consider splitting the larger reference tables (struct field tags, receiver rules, common mistakes) into a bundled reference file to improve progressive disclosure now that the body exceeds 350 lines.

Dimension	Reasoning	Score
Conciseness	Mostly efficient and code-dense with prescriptive rules and tables, but includes some over-explanation Claude already knows ("Embedding promotes the inner type's methods… composition, not inheritance", "A well-designed zero value reduces constructor boilerplate") and a redundant ReadWriter/ReadWriteCloser pair; not a 5 because of those trimmable spots, not a 3 because the bulk earns its place.	4 / 5
Actionability	Copy-paste-ready Go examples, good/bad pairs, and directive tables (field tags, receivers, embedding, common mistakes) cover the common cases concretely; not a 4 because guidance is fully executable rather than having minor gaps.	5 / 5
Workflow Clarity	Well-organized by topic section but it is a design reference with no multi-step process, sequence, or validation checkpoints; not a 2 because the sections are coherent, not a 4+ because no workflow or feedback loop is present (the destructive/batch cap does not apply since the skill is not destructive/batch).	3 / 5
Progressive Disclosure	No bundle files exist, so all content lives in one well-headered ~365-line SKILL.md with clearly signaled sibling-skill cross-references and a Cross-References section; not a 5 because some reference tables could plausibly live in separate files, not a 3 because structure and navigation are good with no nested references.	4 / 5
	Total	16 / 20 Passed

Description

96%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 crisply states capabilities and gives explicit, natural trigger conditions in third person. Only minor overlap risk with sibling Go design skills.

Dimension	Reasoning	Score
Specificity	Lists many concrete, specific actions ("composition, embedding, type assertions, type switches, interface segregation, dependency injection via interfaces, struct field tags, and pointer vs value receivers"), matching the comprehensive-coverage anchor; not a 4 because coverage spans the full domain rather than showing minor gaps.	5 / 5
Completeness	Explicitly answers "what" (the design-pattern list) and "when" ("Use this skill when designing Go types… Also use when the user asks about 'accept interfaces, return structs'…") with concrete trigger phrases; not a 4 because both halves are explicit and specific.	5 / 5
Trigger Term Quality	Packs in natural phrases users actually say ("designing Go types", "type assertions or type switches", "struct field tags for JSON/YAML/DB serialization", "accept interfaces, return structs", "compile-time interface checks"); not a 4 because synonym/variation coverage is broad rather than missing a few terms.	5 / 5
Distinctiveness Conflict Risk	Clearly niched to Go struct/interface design with distinct triggers, but overlaps with closely related sibling skills (golang-dependency-injection, golang-design-patterns) cross-referenced in the body; not a 5 because of that minor overlap risk, not a 3 because the niche is well-defined.	4 / 5
	Total	19 / 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-structs-interfaces/SKILL.md
Commit: 30cdf15

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.