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.
98
100%
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 thoroughly enumerates specific Go data structure topics with precise technical terms that developers would naturally use. It includes a well-crafted 'Use when...' clause with multiple trigger scenarios, and its narrow focus on Go data structures specifically (rather than general Go programming) makes it highly distinctive. The description is comprehensive yet concise, using proper third-person voice throughout.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and topics: slices with internals/capacity growth/preallocation, maps with internals/hash buckets, arrays, container packages, strings.Builder vs bytes.Buffer, generic collections, pointers with unsafe.Pointer and weak.Pointer, and copy semantics. | 3 / 3 |
Completeness | Clearly answers both 'what' (Go data structures covering slices, maps, arrays, containers, pointers, etc.) and 'when' with an explicit 'Use when...' clause listing specific trigger scenarios like choosing/optimizing data structures, implementing generic containers, using unsafe/weak pointers, or questioning slice/map internals. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms a Go developer would use: 'slices', 'maps', 'capacity growth', 'preallocation', 'strings.Builder', 'bytes.Buffer', 'unsafe.Pointer', 'weak.Pointer', 'container/list/heap/ring', 'generic collections', 'copy semantics'. These are all terms users would naturally mention. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a clear niche: Go-specific data structures and their internals. The combination of Go language specificity plus data structure focus (not general Go programming) makes it unlikely to conflict with other skills. Terms like 'unsafe.Pointer', 'slice/map internals', and 'container/' packages are very targeted. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
100%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is an exceptionally well-crafted skill that serves as a comprehensive yet concise reference for Go data structures. It excels at progressive disclosure, with the main file providing actionable summaries and clear pointers to deep-dive references. The combination of executable code examples, decision tables, and a common mistakes section makes it highly actionable while remaining token-efficient.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is lean and efficient throughout. It assumes Claude's competence as a Go engineer, avoids explaining basic concepts, and every section delivers actionable information without padding. Tables are used effectively for quick reference. | 3 / 3 |
Actionability | Provides executable Go code examples for preallocation, generic sets, arrays, and slices.Grow. The best practices are specific and prescriptive (e.g., exact growth formula, specific package functions). The common mistakes table gives concrete fixes. | 3 / 3 |
Workflow Clarity | This is primarily a reference/selection skill rather than a multi-step workflow skill. The best practices summary provides clear numbered guidance, the selection tables make choosing the right data structure unambiguous, and the common mistakes section serves as a validation checkpoint for correct usage. | 3 / 3 |
Progressive Disclosure | Excellent progressive disclosure with a clear overview in the main file and well-signaled one-level-deep references to detailed files (slice-internals.md, map-internals.md, containers.md, generics.md, pointers.md). Cross-references to related skills are clearly organized at the end. | 3 / 3 |
Total | 12 / 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 | |
- Repository
- samber/cc-skills-golang
- Commit
b88f91d
- 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.