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 and explicit trigger clause ('Must use when reading or writing Go files'), which is a strength for completeness. However, the capabilities listed are more like topic categories than concrete actions, and the overly broad trigger of 'any Go file' creates significant conflict risk with other potential Go-related skills. The trigger terms could better cover natural user language like 'golang' or '.go'.
Suggestions
Add natural keyword variations such as 'golang', '.go files', 'Go code', 'Go programming' to improve trigger term coverage.
Narrow the trigger scope from all Go files to specific scenarios like 'Use when designing Go type hierarchies, implementing interfaces, or setting up functional option patterns' to reduce conflict risk with other Go skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Go development) and lists some actions/concepts (custom types, interfaces, functional options, error handling), but these are more like topic areas than concrete actions. It doesn't describe specific operations like 'define custom types with validation methods' or 'implement functional option constructors'. | 2 / 3 |
Completeness | Clearly answers both what ('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 and strong trigger clause. | 3 / 3 |
Trigger Term Quality | Includes 'Go files' which is a natural trigger, but misses common variations like '.go files', 'golang', 'Go code', 'Go programming'. Terms like 'type-first development' and 'functional options' are somewhat niche and not what most users would naturally say. | 2 / 3 |
Distinctiveness Conflict Risk | The trigger 'reading or writing Go files' is very broad and would fire for any Go-related task, potentially conflicting with other Go-specific skills (e.g., Go testing, Go concurrency). The 'Must use' directive makes this especially prone to over-triggering. | 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, actionable Go best-practices skill with excellent concrete code examples covering key patterns (custom types, functional options, error handling, config). Its main weaknesses are moderate verbosity from duplicated patterns and explanatory comments Claude doesn't need, plus a lack of explicit validation/verification steps in the workflow. The content would benefit from trimming redundancy and splitting detailed reference material into separate files.
Suggestions
Remove duplicated patterns (e.g., exhaustive switch appears in both Type-First and Examples sections) and trim rationale phrases that explain obvious concepts to Claude (e.g., 'Panics crash the program').
Add explicit validation checkpoints to the type-first workflow, such as 'Run `go vet ./...` and `go test ./...` after implementation to verify correctness'.
Consider splitting detailed reference sections (Configuration, Functional Patterns, enum examples) into separate files and linking from the main SKILL.md to improve progressive disclosure.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient but includes some redundancy—several patterns are shown twice (e.g., exhaustive switch with default error appears in the Type-First section AND the Examples section). Some inline comments explain things Claude already knows (e.g., 'Panics crash the program', 'Explicit failures are debuggable'). The rationale sentences after each instruction bullet could be trimmed. | 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 structured logging. Every pattern is demonstrated with concrete, compilable code rather than pseudocode or vague descriptions. | 3 / 3 |
Workflow Clarity | The type-first development workflow has a clear 4-step sequence, which is good. However, there are no validation checkpoints or feedback loops—no mention of running tests, using `go vet`, or verifying compilation between steps. For a skill that 'must use when reading or writing Go files,' the absence of a verify-before-commit step is a gap. | 2 / 3 |
Progressive Disclosure | The content is well-organized with clear section headers and logical grouping, but it's a fairly long monolithic document (~200+ lines) with no references to external files. The configuration section and detailed enum/functional-options examples could be split into separate reference files to keep the main skill leaner. | 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
aa009ea
- 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.