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.
87
86%
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 scenarios and constructs it covers, and provides explicit trigger guidance for both proactive use and reactive question-answering. The description uses proper 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 scenarios: preventing panics, silent data corruption, runtime bugs, and enumerates specific Go constructs like nil-prone types (pointers, interfaces, maps, slices, channels), numeric conversions, resource lifecycle (defer in loops), and defensive copying. | 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 developers naturally use when encountering these issues. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — targets a specific niche of defensive/safety-oriented Go coding patterns. The enumerated Go-specific pitfalls (nil panics, append aliasing, map concurrent access, defer in loops) clearly distinguish it from general Go coding skills or other language skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
72%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 defensive Go coding skill with excellent actionability — every pattern includes executable code showing both the anti-pattern and the fix. The progressive disclosure is well done with clear cross-references. The main weakness is redundancy: the best practices summary, detailed sections, and common mistakes table cover the same material three times, which hurts conciseness.
Suggestions
Remove or significantly condense the 'Common Mistakes' table since it repeats information already covered in detail in each section — or keep only the table and remove the summary list at the top.
Consider adding a brief linter-based validation workflow (e.g., 'run staticcheck, fix flagged issues, re-run') to provide a concrete feedback loop for catching these safety issues automatically.
| 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 'Best Practices Summary' duplicates the same content again. The persona line and the safety vs security distinction are minor padding. | 2 / 3 |
Actionability | Every concept is backed by executable, copy-paste-ready Go code with clear ✗ Bad / ✓ Good patterns. The examples are concrete, complete, and demonstrate both the problem and the fix with specific values (e.g., 3B wrapping to -1.29B). | 3 / 3 |
Workflow Clarity | The skill is primarily a reference/checklist rather than a multi-step workflow, so explicit sequencing is less critical. However, for a skill that covers defensive coding patterns, there are no validation checkpoints or feedback loops — e.g., no 'run linter, fix issues, re-run' workflow despite mentioning linters. The content is well-organized by topic but lacks procedural guidance. | 2 / 3 |
Progressive Disclosure | Content is well-structured with clear sections, a summary at the top, and well-signaled one-level-deep references to deep-dive files (nil-safety.md, slice-map-safety.md) and cross-skill references. The main file stays at overview level while pointing to detailed materials. | 3 / 3 |
Total | 10 / 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 | |
b88f91d
Table of Contents
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.