CtrlK
BlogDocsLog inGet started
Tessl Logo

golang-safety

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

Quality

82%

Does it follow best practices?

Impact

No eval scenarios have been run

SecuritybySnyk

Passed

No known issues

SKILL.md
Quality
Evals
Security

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.

DimensionReasoningScore

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.

DimensionReasoningScore

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.

Validation9 / 11 Passed

Validation for skill structure

CriteriaDescriptionResult

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
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.