golang-patterns

Go-specific design patterns and best practices including functional options, small interfaces, dependency injection, concurrency patterns, error handling, and package organization. Use when working with Go code to apply idiomatic Go patterns.

Quality

78%

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 ./.kiro/skills/golang-patterns/SKILL.md

Quality

Content

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

A lean, highly actionable pattern reference built on complete, executable Go examples. Its weaknesses are mild filler prose, no guidance on composing the patterns into a real workflow, and an all-inline structure that forgoes progressive disclosure despite covering eight distinct topics.

Suggestions

Delete the opening blockquote and the 'Benefits' bullet lists, which restate knowledge Claude already has about these patterns.

Add brief selection guidance (e.g., when to use a worker pool vs. a simple goroutine/channel pipeline) so readers can compose patterns into a task.

Split larger topics (concurrency patterns, testing patterns) into references/ files and keep SKILL.md as a concise overview with one-level-deep links.

Dimension	Reasoning	Score
Conciseness	The body is dominated by tight, complete code examples with minimal prose, but there are minor trimmable instances: the opening blockquote ("This skill provides comprehensive Go patterns extending common design principles...") is pure filler, and benefit bullets like "Loose coupling" / "Easier testing and mocking" restate what Claude already knows about small interfaces.	4 / 5
Actionability	Every section provides complete, executable Go code — functional options constructor, worker pool with WaitGroup, context cancellation check, %w error wrapping, errors.Is sentinel matching, table-driven test, and t.Cleanup helper — copy-paste ready and covering the common cases for each pattern. Not a 4 because no section falls back to pseudocode or vague hints.	5 / 5
Workflow Clarity	Each pattern section is unambiguous and self-contained with inline guidance ("Always pass context as first parameter", "Validate dependencies in constructor"). Not a 5 because the skill offers no help composing patterns into a task — e.g., no guidance on when to prefer worker pools vs. other concurrency shapes, and no verification step for the concurrency examples.	4 / 5
Progressive Disclosure	The body (~215 lines, 8 topics) is well-organized with clear section headers and no buried or nested references (no bundle files exist). Not a 5 because everything is inlined in SKILL.md: at this breadth, advanced topics like concurrency and testing patterns are natural candidates for one-level-deep reference files to keep the main file as an overview.	4 / 5
	Total	17 / 20 Passed

Description

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

A solid description with an explicit trigger clause and six concrete topic areas. Its main gaps are missing natural synonyms ("golang", ".go" files) and a trigger clause that is narrower than the skill's actual applicability.

Suggestions

Add natural trigger variations such as "golang" and ".go files" to the description text, not just the metadata globs.

Broaden the 'Use when' clause with concrete scenarios, e.g. "Use when designing Go APIs, structuring Go projects, writing concurrent code, or refactoring Go codebases."

Mention the testing patterns (table-driven tests) the skill actually covers so the description's capability list matches the body.

Dimension	Reasoning	Score
Specificity	Phrases like "functional options, small interfaces, dependency injection, concurrency patterns, error handling, and package organization" name six concrete capability areas. Not a 5 because these are pattern categories rather than concrete actions, and coverage omits testing patterns that the skill body actually contains.	4 / 5
Completeness	Explicitly answers both: "what" is the enumerated pattern list, and "when" via "Use when working with Go code to apply idiomatic Go patterns". Not a 5 because the trigger clause is narrow and slightly circular — it lacks concrete usage scenarios (designing Go APIs, refactoring, structuring projects) that the body's own "When to Use This Skill" section covers.	4 / 5
Trigger Term Quality	"Go", "Go code", "idiomatic Go patterns", "functional options", "dependency injection", "error handling" are terms users would naturally say. Missing common variations such as "golang" and the ".go" file extension (which appear only in the metadata globs, not the description text itself).	4 / 5
Distinctiveness Conflict Risk	"Go-specific design patterns" carves a clear niche; the Go language pin makes triggering for the wrong skill unlikely. Minor overlap risk remains with generic design-patterns skills since functional options and DI are language-agnostic concepts.	4 / 5
	Total	16 / 20 Passed

Validation

87%

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 — 14 / 16 Passed

Validation for skill structure

Criteria	Description	Result
metadata_version	'metadata.version' is missing	Warning
metadata_field	'metadata' should map string keys to string values	Warning

	Total	14 / 16 Passed

Repository: affaan-m/ECC
Path: .kiro/skills/golang-patterns/SKILL.md
Commit: c70874f

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.