Name: golang-safety
Rating: 74.4 (1 reviews)
Author: samber

golang-safety

Defensive Golang coding against accidental bugs — nil panics, typed-nil interfaces, `append` backing-array aliasing, silent int64-to-int32 truncation, float `==` comparison, `defer` inside loops, defensive copies of slices and maps, and usable zero values. Use when a Go program panics on a nil map write or nil pointer dereference, when reviewing code for nil-safety, numeric conversion overflow, or resource lifecycle, or when designing a type whose zero value must be safe. Not for designing concurrent access with goroutines, channels, or sync primitives (→ See `samber/cc-skills-golang@golang-concurrency` skill), not for exploitable vulnerabilities such as injection, weak crypto, or leaked secrets (→ See `samber/cc-skills-golang@golang-security` skill), and not for debugging an already-failing program (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).

Quality

93%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Quality

Content

86%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The body is a well-structured, highly actionable reference: every pittle pairs a bad pattern with a concrete fix, and detail is correctly offloaded to two clearly signaled one-level-deep reference files. Its only weakness is mild redundancy between the inline code sections and the 'Common Mistakes' table.

Suggestions

Trim the 'Common Mistakes' table to entries not already demonstrated by inline code, or convert it to a quick-link index back to the relevant section, to reduce redundancy.

Consolidate the scattered nil-channel guidance (currently only mentioned in the nil-behavior table and a common-mistakes row) into one concrete code example with an init-before-use fix.

Move the repeated cross-skill pointers (golang-concurrency, golang-security, etc.) that appear mid-section into the dedicated 'Cross-References' section to keep the inline body leaner.

Dimension	Reasoning	Score
Conciseness	Lean topical sections with minimal prose and tight ✗/✓ code pairs assume Claude's Go knowledge, but the 'Common Mistakes' table restates fixes already shown in code and a few commentary lines could be trimmed.	4 / 5
Actionability	Each pitfall is backed by executable, copy-paste-ready Go showing the bad and fixed patterns (full slice expression, slices.Clone, epsilon compare, bounds check, sync.Once), covering the common cases.	5 / 5
Workflow Clarity	As a non-procedural reference skill it has no destructive batch workflow requiring validation checkpoints, and its clearly sequenced topical sections with an up-front summary organize the material well, though there is no explicit checkpoint flow by design.	4 / 5
Progressive Disclosure	SKILL.md is a concise overview with two real, one-level-deep reference files clearly signaled inline ('See [Nil Safety Deep Dive](./references/nil-safety.md)' and slice-map deep dive), with no nested reference chains.	5 / 5
	Total	18 / 20 Passed

Description

100%Weight 40%Scale 1-5

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 is comprehensive, concrete, and well-scoped: it states exactly what the skill does, when to use it with natural trigger phrases, and explicitly disambiguates it from adjacent sibling skills. It is a strong exemplar with no vague fluff or over-claims.

Dimension	Reasoning	Score
Specificity	Names the domain ('Defensive Golang coding') and lists many concrete capabilities — nil panics, typed-nil interfaces, append backing-array aliasing, int64-to-int32 truncation, float == comparison, defer in loops, defensive copies, usable zero values — giving comprehensive coverage.	5 / 5
Completeness	Explicitly answers both what (defensive coding against the listed bug classes) and when (panics, code review for nil/numeric/resource lifecycle, zero-value design), plus explicit non-target exclusions.	5 / 5
Trigger Term Quality	Includes natural developer phrases ('panics on a nil map write or nil pointer dereference', 'reviewing code for nil-safety', 'zero value must be safe') with strong synonym coverage; only minor absence of a .go extension mention.	5 / 5
Distinctiveness Conflict Risk	Clear niche (safety vs security vs concurrency) reinforced by explicit cross-references to sibling skills (golang-concurrency, golang-security, golang-troubleshooting) minimizing wrong-skill triggering.	5 / 5
	Total	20 / 20 Passed

Validation

87%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 14 / 16 Passed

Validation for skill structure

Criteria	Description	Result
metadata_field	'metadata' should map string keys to string values	Warning
relative_links	Relative link issues: 2 missing	Warning

	Total	14 / 16 Passed

Repository: samber/cc-skills-golang
Path: skills/golang-safety/SKILL.md
Commit: 19a0626

Reviewed: 2 days ago

Table of Contents

Discovery Implementation Validation

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.