Defensive Golang coding to prevent panics, silent data corruption, and subtle runtime bugs. Use when encountering nil panics, append aliasing, map concurrent access, float comparison pitfalls, or zero-value design questions. Also use when reviewing code for nil-safety, numeric conversion overflow, resource lifecycle issues (defer in loops), or defensive copying of slices and maps.
67
82%
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 clearly defines its scope (defensive Go coding), lists numerous specific concrete actions and pitfalls it addresses, and provides explicit trigger guidance with two 'Use when' clauses. The description uses appropriate third-person voice and includes highly specific Go-language terminology that serves as natural trigger terms.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and concerns: nil panics, append aliasing, map concurrent access, float comparison pitfalls, zero-value design, numeric conversion overflow, resource lifecycle issues (defer in loops), defensive copying of slices and maps. | 3 / 3 |
Completeness | Clearly answers both 'what' (defensive Golang coding to prevent panics, silent data corruption, and subtle runtime bugs) and 'when' with explicit 'Use when...' clauses covering two sets of trigger scenarios. | 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', 'defer in loops', 'defensive copying', 'slices and maps', 'nil-safety', 'numeric conversion overflow'. These are terms developers naturally use when encountering these issues. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — it targets a very specific niche (defensive Go coding patterns and common Go-specific pitfalls) with Go-specific terminology like 'append aliasing', 'defer in loops', and 'zero-value design'. Unlikely to conflict with general 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 defensive coding reference with excellent actionability — every pitfall has concrete, executable Go code with clear good/bad patterns. The main weaknesses are redundancy (the Common Mistakes table and Best Practices Summary largely repeat the detailed sections, and cross-references appear twice) and missing bundle files for the referenced deep-dive documents. The skill would benefit from trimming duplicate content and ensuring referenced files exist.
Suggestions
Remove the duplicate 'Cross-References' section at the bottom and consolidate into one.
Consider removing or significantly trimming the 'Common Mistakes' table since it repeats information already covered with code examples in the body — or keep only the table and remove the detailed sections to avoid duplication.
Provide the referenced bundle files (references/nil-safety.md, references/slice-map-safety.md) so progressive disclosure actually works, or remove the references if they don't exist.
| 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. The 'Best Practices Summary' also duplicates the body. The cross-references section appears twice. However, it generally avoids explaining concepts Claude already knows. | 2 / 3 |
Actionability | Every major pitfall includes fully executable, copy-paste-ready Go code with clear ✗ Bad / ✓ Good patterns. The examples are concrete, realistic, and include specific values (e.g., 3_000_000_000 wrapping to -1294967296). The nil behavior table is immediately usable as a reference. | 3 / 3 |
Workflow Clarity | This is primarily a reference/pattern skill rather than a multi-step workflow skill, so explicit sequencing is less critical. However, the skill lacks validation checkpoints — for instance, there's no guidance on how to verify that defensive copies are working correctly, or how to detect slice aliasing bugs. The linter section mentions tools but doesn't provide a concrete validation workflow. | 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 were provided, so the referenced files don't actually exist. The cross-references section is duplicated. Some inline content (like the full Common Mistakes table) could be in a reference file given it repeats the body. | 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 | |
8c7e016
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.