golang-modernize

Modernize Golang code to use recent language features, standard library improvements, and idiomatic patterns. Trigger proactively when writing or reviewing Go code and old-style patterns are detected, or when encountering a deprecation warning. Also use when the user explicitly asks for modernization, a Go version upgrade, or a CI/tooling refresh.

Quality

76%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./skills/golang-modernize/SKILL.md

Quality

Content

62%

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 modernization guide with a clear workflow, good prioritization framework, and useful reference tables. Its main weaknesses are moderate verbosity (explanatory paragraphs that Claude doesn't need), lack of inline executable code examples (deferred to missing reference files), and some content that could be better split into reference files to keep the main skill leaner.

Suggestions

Add at least 2-3 inline before/after code examples for the highest-priority modernizations (e.g., loop variable shadow copies, math/rand/v2 migration) directly in SKILL.md rather than deferring all examples to references/versions.md.

Trim the scope paragraph and consent check section — these can be reduced to 1-2 lines each since Claude can infer context from the workflow steps.

Consider moving the Deprecated Packages table and the full Migration Priority Guide to a reference file, keeping only the top 5-6 items inline to reduce the main file's token footprint.

Dimension	Reasoning	Score
Conciseness	The skill is fairly well-organized but includes some unnecessary verbosity — the scope paragraph explaining what's included/excluded and why, the consent check explanation, and the persona description add tokens without proportional value. The deprecated packages table and priority guide are efficient, but the workflow section could be tighter.	2 / 3
Actionability	The skill provides concrete tables (deprecated packages, version changelogs), a clear priority list, and references to tooling commands (golangci-lint, govulncheck, go mod tidy). However, it lacks executable before/after code examples directly in the SKILL.md — those are deferred to references/versions.md which is not provided. The workflow steps are procedural but not copy-paste executable.	2 / 3
Workflow Clarity	The workflow is clearly sequenced (check go.mod → check latest version → read .modernize → scan → run linter → suggest → parallelize → test → persist ignored suggestions) with explicit validation steps (run tests before dependency updates, check .modernize to avoid re-suggestions). The two modes (inline vs full-scan) are well-differentiated with clear behavioral boundaries and a consent check mechanism.	3 / 3
Progressive Disclosure	The skill references two external files (references/versions.md and references/tooling.md) for detailed content, which is good structure. However, no bundle files were provided, so we cannot verify these references exist. The SKILL.md itself is quite long with inline tables and priority lists that could arguably be in reference files, and the related skills section at the bottom is a flat list without clear navigation signals.	2 / 3
	Total	9 / 12 Passed

Description

89%

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 description that clearly communicates both what the skill does and when it should be triggered. The explicit trigger conditions covering both proactive and user-requested scenarios are well-articulated. The main weakness is that the 'what' could be more specific by listing concrete modernization actions rather than staying at the category level.

Suggestions

Add specific concrete actions to improve specificity, e.g., 'Replace deprecated ioutil calls, adopt generics where appropriate, update error handling to use errors.Is/As, migrate to slog logging.'

Dimension	Reasoning	Score
Specificity	It names the domain (Golang code) and describes actions at a moderate level ('modernize', 'use recent language features, standard library improvements, and idiomatic patterns'), but doesn't list multiple specific concrete actions like 'replace ioutil with os, use generics, update error wrapping'.	2 / 3
Completeness	Clearly answers both 'what' (modernize Golang code to use recent features, standard library improvements, idiomatic patterns) and 'when' (proactively when old-style patterns detected, deprecation warnings, or user asks for modernization/version upgrade/CI refresh). Explicit trigger guidance is provided.	3 / 3
Trigger Term Quality	Includes strong natural trigger terms: 'Go code', 'Golang', 'modernization', 'Go version upgrade', 'deprecation warning', 'CI/tooling refresh', 'old-style patterns'. These cover a good range of terms users would naturally say.	3 / 3
Distinctiveness Conflict Risk	Highly distinctive — specifically targets Go language modernization, which is a clear niche. The triggers (deprecation warnings, Go version upgrade, old-style patterns) are unlikely to conflict with general Go coding skills or other language skills.	3 / 3
	Total	11 / 12 Passed

Validation

81%

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

Validation for skill structure

Criteria	Description	Result
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
Commit: a5e0e59

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