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.
84
85%
Does it follow best practices?
Impact
78%
1.00xAverage score across 3 eval scenarios
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 clearly defines its scope (Go concurrency patterns), lists numerous specific capabilities and concepts, and provides explicit trigger guidance with both a 'Use when' and 'Also triggers when' clause. The trigger terms are comprehensive, natural, and highly specific to the Go concurrency domain, making it easy for Claude to select this skill appropriately.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and concepts: goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, fan-out/fan-in pipelines, goroutine leaks, race conditions, channel ownership issues, choosing between channels and mutexes. | 3 / 3 |
Completeness | Clearly answers both 'what' (Golang concurrency patterns) and 'when' with an explicit 'Use when...' clause covering writing/reviewing concurrent Go code, plus an 'Also triggers when...' clause for detection scenarios. Both halves are well-articulated. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms a user would say: 'goroutines', 'channels', 'select', 'locks', 'sync primitives', 'errgroup', 'singleflight', 'worker pools', 'fan-out/fan-in', 'goroutine leaks', 'race conditions', 'concurrent Go code'. These are exactly the terms developers use when discussing Go concurrency. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive niche focused specifically on Go concurrency patterns. The trigger terms are domain-specific (goroutines, channels, errgroup, singleflight) and unlikely to conflict with general Go skills or concurrency skills in other languages. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
70%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a well-structured concurrency skill with excellent progressive disclosure and clear workflow organization across three modes. Its main weakness is the lack of inline executable code examples — all concrete patterns are deferred to reference files, which reduces immediate actionability. There's also some unnecessary explanation of concepts Claude already knows (what goroutines are, Go's concurrency model basics).
Suggestions
Add at least 2-3 inline executable code examples for the most critical patterns (e.g., proper select with ctx.Done, errgroup usage, worker pool) rather than deferring all code to reference files.
Remove the opening paragraph explaining Go's concurrency model basics — Claude already knows what goroutines and channels are. Start directly with Core Principles.
Add a concrete code example to the Common Mistakes table for at least the most dangerous anti-patterns (e.g., show the time.After leak and its fix side by side).
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The opening paragraph explains what goroutines and channels are, which Claude already knows. The persona and mode descriptions add some overhead. However, the tables and checklist are efficient. The line 'Go's concurrency model is built on goroutines and channels' is unnecessary context. Overall mostly efficient but with some fat that could be trimmed. | 2 / 3 |
Actionability | The skill provides strong conceptual guidance through tables, checklists, and decision matrices, but contains zero executable code examples in the main body. All code examples are deferred to reference files. The common mistakes table gives concrete fixes but as descriptions rather than executable snippets. For a concurrency skill, at least one concrete code pattern (e.g., worker pool, proper select with ctx.Done) should be inline. | 2 / 3 |
Workflow Clarity | The three modes (Write, Review, Audit) are clearly defined with distinct workflows. The concurrency checklist provides an explicit pre-flight validation sequence. The audit mode has a clear 5-step parallel process. The checklist format with checkboxes serves as validation checkpoints before spawning goroutines. | 3 / 3 |
Progressive Disclosure | Excellent progressive disclosure structure. The main file serves as a concise overview with clear one-level-deep references to detailed content: channels-and-select.md, sync-primitives.md, pipelines.md. Cross-references to related skills are well-signaled. Navigation is intuitive with descriptive link text. | 3 / 3 |
Total | 10 / 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.