go-concurrency-patterns

Master Go concurrency with goroutines, channels, sync primitives, and context. Use when building concurrent Go applications, implementing worker pools, or debugging race conditions.

Quality

50%

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

Fix and improve this skill with Tessl

tessl review fix ./skills/go-concurrency-patterns/SKILL.md

The canonical home for this skill is go-concurrency-patterns in rmyndharis/antigravity-skills

Quality

Content

22%Scale 1-5

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

This skill is essentially a hollow stub that defers all substantive content to a resource file that isn't provided. The SKILL.md body contains zero Go-specific guidance, no code examples, no concrete patterns, and only generic instructions that could apply to any domain. It fails to serve as either a standalone skill or a meaningful overview pointing to deeper resources.

Suggestions

Add at least 2-3 concrete, executable Go code examples covering core patterns (e.g., basic goroutine with WaitGroup, channel-based worker pool, context cancellation) directly in the SKILL.md.

Replace the generic instruction bullets ('Clarify goals, constraints, and required inputs', 'Apply relevant best practices') with Go-concurrency-specific guidance such as 'Always use sync.WaitGroup or errgroup to wait for goroutine completion' and 'Run with -race flag to detect data races'.

Add a workflow section with explicit steps for implementing concurrent patterns, including validation steps like race detection and proper shutdown verification.

Provide the referenced `resources/implementation-playbook.md` bundle file, and include a brief summary of what each section covers so the SKILL.md serves as a useful navigational overview.

Dimension	Reasoning	Score
Conciseness	The 'Use this skill when' and 'Do not use this skill when' sections are somewhat boilerplate and add little value for Claude. The instructions section is generic ('Clarify goals, constraints, and required inputs') rather than Go-concurrency-specific. However, it's not excessively verbose overall.	3 / 5
Actionability	There is no concrete code, no specific commands, no executable examples, and no Go-specific guidance whatsoever. The instructions are entirely generic platitudes like 'Apply relevant best practices and validate outcomes' that could apply to any skill. All actual content is deferred to a resource file that isn't provided.	1 / 5
Workflow Clarity	There are no defined steps, no sequencing, no validation checkpoints, and no workflow of any kind. The four bullet points in Instructions are vague directives with no clear process for implementing concurrent Go patterns.	1 / 5
Progressive Disclosure	The skill references `resources/implementation-playbook.md` for detailed patterns, which is a reasonable one-level-deep reference. However, the bundle file is not provided, so we can't verify the reference exists. The SKILL.md itself contains almost no substantive overview content to serve as a useful entry point—it's essentially an empty shell pointing elsewhere.	3 / 5
	Total	8 / 20 Passed

Description

78%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.

This is a solid skill description that clearly communicates both what the skill covers and when to use it. The explicit 'Use when...' clause with concrete scenarios is a strength. The main weakness is that the 'what' portion lists topic areas rather than specific actionable capabilities, and some common trigger terms like 'deadlock', 'mutex', and 'WaitGroup' are missing.

Suggestions

Replace topic-area listing with concrete actions, e.g., 'Implement worker pools, design fan-out/fan-in patterns, debug race conditions, manage goroutine lifecycles with context'

Add more natural trigger terms and synonyms such as 'deadlock', 'mutex', 'WaitGroup', 'select statement', 'data race', 'channel buffering'

Dimension	Reasoning	Score
Specificity	Names the domain (Go concurrency) and lists key concepts (goroutines, channels, sync primitives, context) but these are more like topic areas than concrete actions. It mentions 'building concurrent applications, implementing worker pools, debugging race conditions' which are somewhat concrete but not comprehensive specific actions like 'create mutex-protected shared state' or 'implement fan-out/fan-in patterns'.	3 / 5
Completeness	Clearly answers both 'what' (Master Go concurrency with goroutines, channels, sync primitives, and context) and 'when' (Use when building concurrent Go applications, implementing worker pools, or debugging race conditions) with an explicit 'Use when...' clause containing concrete trigger phrases.	5 / 5
Trigger Term Quality	Includes good natural keywords users would say: 'goroutines', 'channels', 'sync primitives', 'context', 'worker pools', 'race conditions', 'concurrent Go applications'. Missing some common variations like 'deadlock', 'WaitGroup', 'mutex', 'select statement', 'channel buffering', or 'data race'.	4 / 5
Distinctiveness Conflict Risk	Fairly distinct — focuses specifically on Go concurrency rather than general Go programming or general concurrency concepts. Minor overlap risk with a broader Go programming skill or a general concurrency/parallelism skill, but the specific mention of Go-specific constructs (goroutines, channels) helps differentiate it.	4 / 5
	Total	16 / 20 Passed

Validation

90%

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 — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/go-concurrency-patterns/SKILL.md
Commit: 57c135b

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