golang-safety
Defensive Golang coding to prevent panics, silent data corruption, and subtle runtime bugs. Use whenever writing or reviewing Go code that involves nil-prone types (pointers, interfaces, maps, slices, channels), numeric conversions, resource lifecycle (defer in loops), or defensive copying. Also triggers on questions about nil panics, append aliasing, map concurrent access, float comparison, or zero-value design.
84
82%
Does it follow best practices?
Impact
Pending
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 clearly defines its scope (defensive Go coding), lists specific concrete concerns and patterns it addresses, and provides explicit trigger guidance for both proactive use and reactive question-answering. The description uses appropriate third-person voice and includes highly relevant, natural trigger terms that Go developers would actually use.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and concerns: preventing panics, silent data corruption, runtime bugs, and enumerates specific areas like nil-prone types, numeric conversions, resource lifecycle (defer in loops), defensive copying, append aliasing, map concurrent access, float comparison, and zero-value design. | 3 / 3 |
Completeness | Clearly answers both 'what' (defensive Go coding to prevent panics, data corruption, and runtime bugs) and 'when' with explicit triggers ('Use whenever writing or reviewing Go code that involves...' and 'Also triggers on questions about...'). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms a Go developer would use: 'nil panics', 'append aliasing', 'map concurrent access', 'float comparison', 'zero-value design', 'defer in loops', 'pointers', 'interfaces', 'maps', 'slices', 'channels', 'numeric conversions'. These are terms users would naturally mention when encountering these issues. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — focuses specifically on defensive Go coding patterns and common Go-specific pitfalls. The enumerated concerns (nil panics, append aliasing, map concurrent access, defer in loops) are very specific to this skill's niche and unlikely to conflict with general Go coding or other language skills. | 3 / 3 |
Total | 12 / 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 strong, actionable defensive Go coding reference with excellent concrete examples covering the most common safety pitfalls. Its main weaknesses are redundancy (the Common Mistakes table repeats earlier content, Cross-References appears twice) and the absence of referenced bundle files that would support the progressive disclosure structure. The catalog-style organization is appropriate for the topic but lacks integrated validation workflows.
Suggestions
Remove the duplicate Cross-References section and consolidate the Common Mistakes table with the detailed sections above to reduce redundancy.
Provide the referenced bundle files (references/nil-safety.md, references/slice-map-safety.md) or remove the references if they don't exist.
Add a brief 'verification workflow' section suggesting running specific linters (errcheck, forcetypeassert) after applying these patterns, creating a feedback loop.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient with good code examples and tables, but has some redundancy: the 'Common Mistakes' table at the end largely repeats information already covered in detail in the preceding sections, and the Cross-References section appears twice. The persona line and introductory framing add minor bloat. | 2 / 3 |
Actionability | Every major concept includes executable, copy-paste-ready Go code with clear ✗ Bad / ✓ Good patterns. The guidance is concrete and specific — exact code fixes, exact function signatures, exact numeric examples (e.g., 3B → -1.29B wraparound). | 3 / 3 |
Workflow Clarity | The skill is organized as a reference catalog of individual defensive patterns rather than a multi-step workflow, which is appropriate for its purpose. However, there are no explicit validation checkpoints or feedback loops — for example, no 'run linter after applying these patterns' step integrated into a workflow, just a mention to see a separate linting skill. | 2 / 3 |
Progressive Disclosure | The skill references deep-dive files (nil-safety.md, slice-map-safety.md) and cross-references other skills, which is good structure. However, no bundle files are provided, so the referenced files don't actually exist, and the cross-references section is duplicated. The inline content is substantial but reasonably organized with clear headers. | 2 / 3 |
Total | 9 / 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
e9761db
- 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.