Name: golang-design-patterns
Rating: 69.6 (1 reviews)
Author: samber

golang-design-patterns

Idiomatic Golang design patterns — functional options, constructor APIs, `init()` and global-state avoidance, enums, panic vs error decisions, resource management and lifecycle, graceful shutdown, timeouts and retries, streaming and iterators, and architecture styles (clean, hexagonal, DDD, flat). Apply when choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns, or asking which idiomatic Go pattern fits a specific problem. Not for wiring a DI container or comparing DI libraries (→ See `samber/cc-skills-golang@golang-dependency-injection` skill), nor for error wrapping, `errors.Is`/`As`, or logging mechanics (→ See `samber/cc-skills-golang@golang-error-handling` skill).

Quality

85%

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

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 well-structured and actionable with copy-paste Go examples, clear Design/Review modes, and clean one-level-deep progressive disclosure to verified reference files. It could be tightened by reducing overlap between the Best Practices Summary and the dedicated sections, and by adding a small inline streaming/iterator example.

Suggestions

Collapse or cross-link the 21-item Best Practices Summary against the dedicated sections to remove restated content (e.g., functional options, init(), enums appear twice).

Add a brief inline iterator/streaming code snippet so the 'Iterators & Streaming for Large Data' section is self-contained rather than reference-only.

Include one inline retry-with-backoff snippet using `select` on `ctx.Done()` instead of only pointing to the golang-context skill.

Dimension	Reasoning	Score
Conciseness	Lean directive prose ('Avoid `init()`', 'Panic is for bugs') with tight code examples and no padding about Go basics, but the 21-item Best Practices Summary restates topics then expanded in dedicated sections, so a few tokens are duplicated.	4 / 5
Actionability	Copy-paste-ready Go examples for the common cases (functional options, init, enums, regexp, embed, defer Close, timeouts) are concrete and executable; minor gaps where streaming/iterators and retry logic point to references without inline code.	4 / 5
Workflow Clarity	Design and Review modes give a clear sequenced process ('ask the developer about their architecture preference before proposing patterns'; 'scan for ... report findings before suggesting refactors'); no validation checkpoints, but the skill is not a destructive/batch workflow so they are not required.	4 / 5
Progressive Disclosure	A concise overview body with a 'Detailed Guides' table and inline links to six verified one-level-deep reference files (architecture, clean-architecture, hexagonal-architecture, ddd, data-handling, resource-management), with detail appropriately split out and easy to navigate.	5 / 5
	Total	17 / 20 Passed

Description

92%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 strong: it enumerates concrete capabilities, gives explicit 'Apply when' triggers, and adds negative boundary guidance to avoid overlap with sibling skills. The only minor gap is trigger phrasing that favors pattern jargon over the most colloquial user terms.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions/patterns — 'functional options, constructor APIs, `init()` and global-state avoidance, enums, panic vs error decisions, resource management and lifecycle, graceful shutdown, timeouts and retries, streaming and iterators' — giving comprehensive coverage of the domain.	5 / 5
Completeness	Explicitly answers both what (the enumerated pattern list) and when ('Apply when ... or asking which idiomatic Go pattern fits a specific problem') with concrete trigger phrases.	5 / 5
Trigger Term Quality	'Apply when choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns' provides good natural-phrase coverage, but the triggers lean on pattern names and omit a few colloquial variations a user might say.	4 / 5
Distinctiveness Conflict Risk	Clear niche (Go design patterns) with explicit 'Not for ... (→ See ...golang-dependency-injection ...)' and '...golang-error-handling' boundary guidance that actively suppresses conflict with sibling skills.	5 / 5
	Total	19 / 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-design-patterns/SKILL.md
Commit: 19a0626

Reviewed: 1 day 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.