golang-patterns

Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications.

Quality

53%

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 ./docs/zh-TW/skills/golang-patterns/SKILL.md

Quality

Content

57%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 a well-organized, highly actionable catalog of idiomatic Go patterns with executable code, real tool commands, and a linter config, but it is a single monolithic 675-line file that spends much of its budget re-teaching standard-library knowledge Claude already has. Splitting topics into reference files and trimming known material would improve both conciseness and progressive disclosure.

Suggestions

Split large topics (concurrency patterns, interface design, tooling/linter config) into one-level-deep reference files under references/ and keep SKILL.md as a concise overview with clear links.

Remove content Claude already knows — redefinitions of io.Reader/Writer/Closer, nil-map panics, and string-concatenation examples — and keep only genuinely opinionated or project-specific guidance.

Turn the tools section into a short validation workflow (e.g. after applying a pattern: 'go vet ./...', 'go test -race ./...', then golangci-lint run) so changes are tied to explicit verification checkpoints.

Dimension	Reasoning	Score
Conciseness	The body is code-first with minimal prose, but at ~675 lines it spends significant tokens on material Claude already knows — it redefines the stdlib io.Reader/Writer/Closer interfaces, shows 'avoid string concatenation in loops' with strings.Builder/strings.Join, and explains that nil maps panic. This fits 'mostly efficient but includes some unnecessary explanation or could be tightened', not 4, given how much of the catalog is standard Go knowledge.	3 / 5
Actionability	Nearly every section provides complete, executable Go examples, real commands ('go test -race ./...', 'golangci-lint run', 'go vet ./...'), and a full .golangci.yml configuration. It is not a 5 because several snippets depend on undefined helpers (db.FindUser, process(job), fetch(url)), so they are illustrative rather than copy-paste runnable.	4 / 5
Workflow Clarity	This is a pattern catalog rather than a multi-step workflow: '何時啟用' gives use triggers and the tools section lists verification commands (go vet, go test -race), but they are presented as flat catalogs with no sequencing or validation checkpoints connecting 'apply a pattern' to 'verify with go vet / tests'. Fits anchor 3 ('sequence/checkpoints present but implicit or missing'); not 4 because no checkpoint ever ties changes to verification.	3 / 5
Progressive Disclosure	No bundle files exist and all content is inlined in a single 675-line SKILL.md, yet the file has clear hierarchical sections (core principles, error handling, concurrency, interfaces, packages, performance, tooling), which is more than anchor 2's headerless inlined wall. It fits anchor 3 — real structure, but content that clearly belongs in separate reference files (e.g. concurrency patterns, tooling config) is inline with no external references to offload it.	3 / 5
	Total	13 / 20 Passed

Description

48%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 clearly identifies its Go niche but is a single generic capability sentence: it lists no concrete actions, includes no 'Use when' trigger guidance, and misses the most common user phrasing ('golang'). It reads as a topic label rather than a capability-plus-trigger description.

Suggestions

Add a 'Use when...' clause, e.g. 'Use when writing, reviewing, or refactoring Go code, or when the user mentions Go, golang, goroutines, or Go modules.'

Replace generic capability words ('best practices, and conventions') with concrete actions such as 'apply error-wrapping and sentinel-error patterns, design interfaces, structure packages, and manage goroutine concurrency'.

Include common user synonyms and terms like 'golang', 'goroutine', 'channel', and 'go.mod' to strengthen trigger matching.

Dimension	Reasoning	Score
Specificity	The description names the domain ("Idiomatic Go patterns") but its capability terms — "best practices, and conventions for building robust, efficient, and maintainable Go applications" — are generic labels rather than concrete actions, matching the anchor 'Names the domain but actions are minimal or generic'. It is not a 3 because no specific actions like error handling, concurrency, or refactoring are listed.	2 / 5
Completeness	The 'what' is clearly stated (idiomatic Go patterns, best practices, conventions) but there is no 'Use when...' clause or equivalent trigger guidance, which caps completeness at 3 per the judging guidelines. It is not a 4 precisely because the 'when' is entirely missing rather than just imprecise.	3 / 5
Trigger Term Quality	Phrases like "Idiomatic Go patterns" and "best practices" are relevant, but the description misses the most natural variations users say — "golang", "goroutine", "concurrency", "error handling" — matching 'Some relevant keywords but missing common variations or synonyms'. It is not a 4 because several natural trigger terms are absent.	3 / 5
Distinctiveness Conflict Risk	"Idiomatic Go patterns" carves out a clear language-specific niche with minimal overlap risk against non-Go skills, fitting 'Mostly distinct; minor overlap risk with closely related skills'. It is not a 5 because without explicit trigger phrases it could still collide with general code-style or refactoring skills.	4 / 5
	Total	12 / 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
skill_md_line_count	SKILL.md is long (675 lines); consider splitting into references/ and linking	Warning

	Total	15 / 16 Passed

Repository: affaan-m/ECC
Path: docs/zh-TW/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.