Name: golang-concurrency
Rating: 82.13000000000001 (1 reviews)
Author: samber

golang-concurrency

Golang concurrency design — goroutine lifecycle and leak prevention, channels and `select`, channel ownership and direction, `sync.Mutex`/`RWMutex`/`sync.Map`/`sync.Once`/atomics, `errgroup`, `singleflight`, worker pools, and fan-out/fan-in pipelines. Use when writing or reviewing concurrent Go code, when choosing between channels and mutexes, when protecting a shared map or counter, or when a goroutine has no clear exit. Not for defensive coding unrelated to concurrency such as nil panics, slice aliasing, or numeric overflow (→ See `samber/cc-skills-golang@golang-safety` skill), and not for debugging a specific hung, crashing, or racing program after the fact (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).

1.40x

Quality

89%

Does it follow best practices?

Impact

70%

1.40x

Average score across 2 eval scenarios

Securityby

Passed

No findings from the security scan

Quality

Content

78%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, token-efficient reference that assumes Go expertise and pushes detailed code into three clearly-linked reference files. Its main weakness is inline Go version-number sprawl and the absence of explicit write-mode validation checkpoints.

Suggestions

Consolidate the scattered Go version qualifiers (1.19+/1.21+/1.23+/1.25+/1.26/1.27) into a single 'Version-specific notes' or 'Old patterns' section so the main tables stay version-agnostic and concise.

Add one small inline executable snippet for the most common pattern (e.g. an errgroup.WithContext worker) so the body is self-sufficient for the common case without requiring a reference hop.

For write mode, add an explicit validation checkpoint such as 'run go test -race ./... and go.uber.org/goleak verification before declaring done' to turn the reference material into a sequenced workflow with feedback.

Dimension	Reasoning	Score
Conciseness	The body is largely lean tables and lists that assume Go competence, but the intro paragraph and scattered inline Go version numbers (1.19+/1.21+/1.25+/1.23+/1.26/1.27) add tokens that, per the rubric, should live in a deprecated/old-patterns section rather than inline.	4 / 5
Actionability	Concrete API names, primitives, and executable commands (go test -race ./..., go.uber.org/goleak, pprof curl URLs, errgroup.SetLimit(n)) are present, but inline copy-paste code examples for the core patterns are deferred to reference files rather than shown.	4 / 5
Workflow Clarity	Three modes are clearly defined and the audit section gives a well-sequenced 5-step sub-agent plan plus a pre-spawn checklist, but write mode relies on 'follow the sequential instructions below' without explicit validation checkpoints.	4 / 5
Progressive Disclosure	The body is a clear overview with well-signaled, one-level-deep references (channels-and-select.md, sync-primitives.md, pipelines.md) that all resolve to real bundle files, splitting detail appropriately and keeping navigation easy.	5 / 5
	Total	17 / 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 a strong, third-person skill descriptor: it names concrete capabilities, gives explicit 'Use when' triggers, and carves clear boundaries against sibling skills. It is dense but every clause carries information rather than padding.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete capabilities — 'goroutine lifecycle and leak prevention', 'channels and select', 'channel ownership and direction', the full sync primitive set, 'errgroup', 'singleflight', 'worker pools', and 'fan-out/fan-in pipelines' — giving comprehensive coverage rather than vague claims.	5 / 5
Completeness	Explicitly answers both 'what' (the enumerated capability list) and 'when' ('Use when writing or reviewing concurrent Go code...'), with concrete trigger phrases and an explicit 'Not for...' boundary section.	5 / 5
Trigger Term Quality	Natural phrases a Go developer would actually say — 'writing or reviewing concurrent Go code', 'choosing between channels and mutexes', 'protecting a shared map or counter', 'a goroutine has no clear exit' — with synonym coverage across the channel/mutex/atomic space.	5 / 5
Distinctiveness Conflict Risk	Clear concurrency niche with distinct triggers, and explicit out-of-scope routing to sibling skills (golang-safety, golang-troubleshooting) minimizes overlap and wrong-skill triggering.	5 / 5
	Total	20 / 20 Passed

Validation

93%

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 — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
metadata_field	'metadata' should map string keys to string values	Warning

	Total	15 / 16 Passed

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

Reviewed: 6 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.