golang-concurrency

Golang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions, channel ownership issues, or need to choose between channels and mutexes.

1.30x

Quality

92%

Does it follow best practices?

Impact

86%

1.30x

Average score across 2 eval scenarios

Securityby

Passed

No findings from the security scan

Quality

Content

85%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 overview that delegates detail to three real one-level-deep reference files and anchors risky actions with a pre-spawn checklist and a sequenced parallel-audit workflow. Its main weakness is that nearly all executable code lives in the references rather than inline, slightly reducing standalone actionability.

Suggestions

Inline one or two short copy-paste code snippets (e.g., an errgroup.WithContext worker pattern) in SKILL.md so the most common case is executable without opening a reference.

Trim the restated definition of goroutines/channels in the opening paragraph and condense the Go 1.26 pprof curl examples to save tokens.

Add an explicit validation feedback loop for the audit workflow (e.g., 're-run -race after applying fixes') to strengthen the recovery path beyond the checklist.

Dimension	Reasoning	Score
Conciseness	Mostly lean — decision tables, terse principles, and one-level-deep references assume Claude's Go competence without explaining basics. Minor padding: the opening paragraph restates what goroutines are and the Go 1.26 section's curl/pprof commands could be trimmed.	4 / 5
Actionability	Mostly executable guidance via concrete decision tables (Channel vs Mutex vs Atomic, WaitGroup vs errgroup) and specific API recommendations (errgroup.SetLimit(n), atomic.Int64). However the body leans on tables and rules rather than inline copy-paste code, deferring almost all executable examples to the reference files.	4 / 5
Workflow Clarity	The pre-spawn Concurrency Checklist provides an explicit validation gate before spawning goroutines, and the 5-step parallel audit workflow is a clearly sequenced procedure with concrete per-agent tasks — both are explicit checkpointed workflows with feedback loops (validate-then-spawn, consolidate findings).	5 / 5
Progressive Disclosure	SKILL.md is a tight overview with well-signaled one-level-deep references — [Channels and Select Patterns](references/channels-and-select.md), [Sync Primitives Deep Dive](references/sync-primitives.md), and [Pipelines and Worker Pools](references/pipelines.md) — all of which are real files present in the bundle, with no nested/deep references.	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 exemplary: it names the domain, enumerates concrete capabilities with specific Go primitives, and provides explicit 'Use when' and 'Also triggers when' clauses covering both positive and defensive triggers. It is concise yet comprehensive and clearly distinguishable from sibling Go skills.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions (writing/reviewing concurrent Go code) with specific mechanisms named — goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, fan-out/fan-in — giving comprehensive coverage of the skill's capabilities.	5 / 5
Completeness	Explicitly answers 'what' (Golang concurrency patterns with enumerated mechanisms) and 'when' ('Use when writing or reviewing concurrent Go code involving...' and 'Also triggers when you detect goroutine leaks...') with concrete trigger phrases.	5 / 5
Trigger Term Quality	Natural trigger phrases users would say are present in abundance — 'goroutine leaks', 'race conditions', 'channel ownership', plus concrete Go API terms (channels, select, errgroup) and a 'Use when...' clause covering writing/reviewing concurrent Go code.	5 / 5
Distinctiveness Conflict Risk	Carves a clear niche (Go concurrency specifically) with distinct triggers — goroutine leaks, channel ownership, channels vs mutexes — that are unlikely to collide with adjacent Go skills like performance or context, minimizing conflict risk.	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: 30cdf15

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