CtrlK
BlogDocsLog inGet started
Tessl Logo

golang-design-patterns

Idiomatic Golang design patterns — functional options, constructors, error flow and cascading, resource management and lifecycle, graceful shutdown, resilience, architecture, dependency injection, data handling, streaming, and more. Apply when explicitly 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.

67

Quality

82%

Does it follow best practices?

Impact

No eval scenarios have been run

SecuritybySnyk

Passed

No known issues

SKILL.md
Quality
Evals
Security

Quality

Content

72%

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 Go design patterns skill that provides executable code examples for core patterns and effectively delegates detailed topics to referenced files and companion skills. Its main weakness is some redundancy between the 21-item summary list and the detailed sections, plus the cross-references section duplicating inline references. The workflow/decision-making guidance for choosing between patterns could be more structured.

Suggestions

Trim the 21-item best practices summary to only items not covered in detail below, or remove the detailed sections and keep only the summary with references — the current structure has significant overlap.

Add a concrete decision tree or flowchart for the Design mode (e.g., 'If <3 config options → simple constructor; if validation needed between steps → builder; otherwise → functional options') to improve workflow clarity.

DimensionReasoningScore

Conciseness

Generally efficient with good use of tables and concise code examples, but the 21-item best practices summary is somewhat redundant with the detailed sections that follow. Some explanatory text (e.g., explaining why init() is bad, string vs []byte rationale) could be tighter since Claude knows Go well. The cross-references section at the end repeats references already made inline.

2 / 3

Actionability

Provides fully executable, copy-paste ready Go code for functional options, defer patterns, timeout patterns, embed directives, enum declarations, and regex compilation. The code examples are complete and idiomatic, with clear usage examples (e.g., the NewServer call with options).

3 / 3

Workflow Clarity

This is a pattern catalog rather than a multi-step workflow, so strict sequencing is less critical. However, the two operational modes (Design mode and Review mode) are described but lack concrete validation checkpoints or decision trees. The architecture section says 'ask the developer' but doesn't provide a structured decision flow for choosing between patterns.

2 / 3

Progressive Disclosure

Excellent structure with a concise overview, inline code for core patterns, and well-signaled one-level-deep references to detailed guides (references/data-handling.md, references/resource-management.md, references/architecture.md, etc.) and cross-skill references. The detailed guides table is clear and navigable. Content is appropriately split between the main file and references.

3 / 3

Total

10

/

12

Passed

Description

92%

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 strong skill description that clearly enumerates specific Go design patterns and provides an explicit 'Apply when...' clause with concrete trigger scenarios. The description uses proper third-person voice and avoids vague language. The only minor weakness is potential overlap with general Go development or software architecture skills, though the 'idiomatic' qualifier and specific pattern names help mitigate this.

DimensionReasoningScore

Specificity

Lists multiple specific concrete patterns: functional options, constructors, error flow and cascading, resource management and lifecycle, graceful shutdown, resilience, architecture, dependency injection, data handling, streaming. These are all concrete, recognizable Go design patterns.

3 / 3

Completeness

Clearly answers both 'what' (idiomatic Golang design patterns covering functional options, constructors, error flow, etc.) and 'when' (explicit 'Apply when...' clause listing specific trigger scenarios like choosing between architectural patterns, implementing functional options, designing constructor APIs).

3 / 3

Trigger Term Quality

Includes strong natural keywords users would say: 'functional options', 'constructors', 'graceful shutdown', 'resilience patterns', 'dependency injection', 'idiomatic Go', 'architectural patterns'. These are terms Go developers naturally use when seeking guidance on these topics.

3 / 3

Distinctiveness Conflict Risk

While it's specific to Go and design patterns, terms like 'architecture', 'dependency injection', 'error flow', and 'data handling' could overlap with general Go coding skills or broader software architecture skills. The focus on 'idiomatic' patterns helps but some overlap risk remains with general Go development skills.

2 / 3

Total

11

/

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.

Validation9 / 11 Passed

Validation for skill structure

CriteriaDescriptionResult

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