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.
73
92%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
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.
This is an excellent skill description that thoroughly covers specific Go struct and interface design patterns with concrete actions, comprehensive trigger terms, and explicit 'Use when' guidance. It uses proper third-person voice throughout and provides enough detail to clearly distinguish it from other Go-related or general programming skills. The description is detailed without being padded with fluff.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and concepts: composition, embedding, type assertions, type switches, interface segregation, dependency injection via interfaces, struct field tags, pointer vs value receivers. These are all concrete, well-defined Go programming concepts. | 3 / 3 |
Completeness | Clearly answers both 'what' (Golang struct and interface design patterns with specific enumeration) and 'when' (explicit 'Use this skill when...' clause listing multiple trigger scenarios, plus an 'Also use when...' clause for additional triggers). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms a Go developer would use: 'Go types', 'interfaces', 'embedding structs', 'type assertions', 'type switches', 'struct field tags', 'JSON/YAML/DB serialization', 'pointer and value receivers', 'accept interfaces, return structs', 'compile-time interface checks'. These are all terms users would naturally say when seeking help with these topics. | 3 / 3 |
Distinctiveness Conflict Risk | Highly specific to Go struct and interface design patterns, which is a clear niche. The trigger terms are distinctly Go-specific (embedding, value receivers, 'accept interfaces return structs') and unlikely to conflict with general programming skills or other Go-related skills focused on different areas. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
85%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a strong, well-structured Go skill covering struct and interface design patterns comprehensively. The code examples are executable and the good/bad pattern comparisons make guidance immediately actionable. Minor verbosity in explanatory prose (concepts Claude already understands like what embedding or DI means) prevents a perfect conciseness score, but overall token efficiency is reasonable for the breadth of topics covered.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is generally well-written but includes some explanatory content Claude already knows (e.g., explaining what embedding does, what type assertions are, what dependency injection is). The standard library interfaces table and some of the explanatory prose could be trimmed. However, it avoids the worst verbosity and most content earns its place. | 2 / 3 |
Actionability | Every section includes concrete, executable Go code examples that are copy-paste ready. The guidance is specific with clear good/bad patterns, concrete struct definitions, and real method signatures. The common mistakes table provides actionable fixes. | 3 / 3 |
Workflow Clarity | This is primarily a design patterns/conventions skill rather than a multi-step workflow skill. For its purpose, the sequencing is clear: principles are logically ordered from interface design → struct design → embedding → DI → tags → receivers. Decision tables (embed vs named field, pointer vs value) provide clear guidance for choosing between approaches. | 3 / 3 |
Progressive Disclosure | The skill has a clear structure with well-organized sections and a dedicated Cross-References section pointing to related skills (naming, design patterns, DI, code style) as one-level-deep references. Content is appropriately scoped to structs and interfaces without trying to cover everything inline. | 3 / 3 |
Total | 11 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
metadata_field | 'metadata' should map string keys to string values | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Repository
- samber/cc-skills-golang
- Commit
8c7e016
- Reviewed
Table of Contents
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.