golang-data-structures

Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container/ packages, unsafe or weak pointers, or questioning slice/map internals.

Quality

88%

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

85%

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

A well-structured, actionable reference skill with real one-level-deep bundle files and clear decision guidance. The only meaningful deduction is the inline Go version numbers, which the rubric treats as time-sensitive content that should live in a deprecated/old-patterns section.

Suggestions

Consolidate Go-version gates (1.18+, 1.21+, 1.23+, 1.24+) into a single 'Minimum Go versions' note or move older-pattern items into a clearly labeled 'Deprecated / old patterns' section so the main flow stays version-agnostic and concise.

Keep the tight MUST/SHOULD/NEVER style in the Best Practices Summary — it is the strongest part of the body and could be promoted even earlier as the primary decision entry point.

Dimension	Reasoning	Score
Conciseness	The body is lean and assumes Go competence (no basic-concept fluff), but inline version gates such as '(Go 1.21+)', '(1.23+)', '(Go 1.24+)' are scattered throughout with no 'deprecated/old patterns' section, and the rubric penalizes version numbers outside such a section.	2 / 3
Actionability	It provides fully executable, copy-paste-ready code — 'make([]User, 0, len(ids))', 'slices.Grow(s, additionalNeeded)', 'make(map[string]*User, len(users))', and a generic Set[T] with Add/Contains — plus concrete decision tables and Common Mistakes fixes.	3 / 3
Workflow Clarity	This is a selection/reference skill with no destructive multi-step process; per the rubric's simple-skill allowance, the Best Practices Summary, decision tables (container/, copy semantics), and Common Mistakes give an unambiguous selection procedure without needing validation checkpoints.	3 / 3
Progressive Disclosure	The body is a concise overview with well-signaled, one-level-deep links to real reference files (e.g. '[Slice Internals Deep Dive](./references/slice-internals.md) — Full slices package reference…'), all five of which exist in ./references/, with no nested-reference chains.	3 / 3
	Total	11 / 12 Passed

Description

92%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong, concrete description with an explicit 'Use when' trigger clause and natural terms, clearly answering both what and when. Its main weakness is overlap risk with sibling golang-* skills around 'optimizing' and 'copy semantics'.

Suggestions

Sharpen the 'Use when' triggers to scope out sibling skills — e.g. drop or narrow 'optimizing' (owned by golang-performance) and clarify that copy-semantics guidance here is about data-structure value/reference behavior rather than general defensive copying (owned by golang-safety).

Consider trimming the long topic parenthetical to the highest-signal items so the description stays scannable without losing specificity.

Dimension	Reasoning	Score
Specificity	The description enumerates concrete, specific capabilities — 'slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics' — listing multiple specific concrete items rather than vague actions.	3 / 3
Completeness	It explicitly answers both 'what' (the data-structure catalog) and 'when' via the explicit 'Use when choosing or optimizing Go data structures, implementing generic containers…' trigger clause.	3 / 3
Trigger Term Quality	The 'Use when' clause supplies natural terms a Go developer would actually say — 'Go data structures', 'generic containers', 'container/ packages', 'unsafe or weak pointers', 'slice/map internals' — giving good coverage of common phrasings.	3 / 3
Distinctiveness Conflict Risk	The data-structures niche is clear, but 'optimizing Go data structures' and 'copy semantics' overlap with the sibling golang-performance, golang-safety, and golang-design-patterns skills the body itself cross-references, so it could still trigger for a related skill.	2 / 3
	Total	11 / 12 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
allowed_tools_field	'allowed-tools' contains unusual tool name(s)	Warning
metadata_field	'metadata' should map string keys to string values	Warning

	Total	14 / 16 Passed

Repository: samber/cc-skills-golang
Path: skills/golang-data-structures/SKILL.md
Commit: 4158351

Reviewed: about 14 hours 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.