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.
76
66%
Does it follow best practices?
Impact
91%
1.10xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./data/skills-md/0xbigboss/claude-code/go-best-practices/SKILL.mdQuality
Discovery
67%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 has a clear 'when' clause which is a strength, but the 'what' is somewhat vague—listing topic areas rather than concrete actions. The trigger is overly broad ('reading or writing Go files') which means it would activate for all Go work, creating potential conflicts with other Go-related skills. Adding common keyword variations like 'golang' and '.go' would improve discoverability.
Suggestions
Add common trigger term variations such as 'golang', '.go files', and 'Go code' to improve keyword coverage.
Narrow the trigger condition from all Go file operations to specific scenarios like 'when defining custom types, designing interfaces, implementing functional options patterns, or structuring error handling in Go'.
Replace 'Provides Go patterns' with more concrete actions like 'Defines custom types, designs interfaces, implements functional options, and structures error handling in Go code'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Go development) and lists some specific concepts (custom types, interfaces, functional options, error handling), but these are more like topic areas than concrete actions. It says 'provides patterns' which is somewhat vague about what it actually does. | 2 / 3 |
Completeness | Clearly 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'), with an explicit trigger clause. | 3 / 3 |
Trigger Term Quality | Includes 'Go files' and 'Go' as natural keywords, but misses common variations like '.go files', 'golang', 'Go code', 'Go programming'. The specific concepts listed (functional options, type-first development) are more niche than what typical users would say. | 2 / 3 |
Distinctiveness Conflict Risk | The trigger 'reading or writing Go files' is very broad and would fire for ANY Go-related task, which could conflict with other Go-specific skills (e.g., Go testing, Go concurrency). The description doesn't narrow its niche enough beyond general Go development patterns. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid Go best practices skill with excellent actionability—nearly every pattern is backed by executable code. Its main weaknesses are some redundancy between sections (patterns repeated in both main content and Examples), explanatory commentary that Claude doesn't need, and a lack of validation/verification steps in the workflow. The content would benefit from trimming duplicated examples and adding explicit verification checkpoints.
Suggestions
Remove duplicated patterns between the Type-First Development section and the Examples section (e.g., exhaustive switch, error wrapping appear twice with near-identical code)
Remove explanatory sentences that state things Claude already knows, such as 'Panics crash the program' and 'Explicit failures are debuggable'
Add validation checkpoints to the workflow, such as 'run go vet and go build after changes' or 'run tests to verify behavior'
Consider splitting the detailed config and functional options examples into a referenced file to keep the main skill leaner
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is reasonably efficient but includes some redundancy—patterns like exhaustive switch and error wrapping appear both in the Type-First Development section and again in the Examples section. Some explanatory sentences after bullet points ('This preserves the error chain for debugging', 'Panics crash the program') explain things Claude already knows. | 2 / 3 |
Actionability | The skill provides fully executable, copy-paste ready Go code examples throughout—custom types, functional options, error wrapping, config loading, enums with iota, and more. Every pattern is demonstrated with concrete, compilable code. | 3 / 3 |
Workflow Clarity | The type-first development workflow has a clear 4-step sequence, but there are no validation checkpoints or feedback loops. For a skill that 'must use when reading or writing Go files,' there's no guidance on verifying correctness (e.g., running tests, go vet, or compilation checks after changes). | 2 / 3 |
Progressive Disclosure | The content is well-structured with clear headers and logical sections, but it's a fairly long monolithic file (~200+ lines of code examples) with no references to external files for deeper topics like testing patterns or module structure details. Some sections (e.g., the detailed config example) could be split out. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- NeverSight/skills_feed
- Commit
f772de4
- 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.