golang-modernize
Continuously modernize Golang code to use the latest language features, standard library improvements, and idiomatic patterns. Use this skill whenever writing, reviewing, or refactoring Go code to ensure it leverages modern Go idioms. Also use when the user asks about Go upgrades, migration, modernization, deprecation, or when modernize linter reports issues. Also covers tooling modernization: linters, SAST, AI-powered code review in CI, and modern development practices. Trigger this skill proactively when you notice old-style Go patterns that have modern replacements.
76
72%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/golang-modernize/SKILL.mdQuality
Discovery
82%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 solid description that clearly communicates both what the skill does and when to use it, with good trigger term coverage for Go modernization scenarios. Its main weaknesses are that the specific capabilities could be more concrete (e.g., listing specific modern Go features like generics, errors.Is/As, slog) and the scope is broad enough that it could conflict with other Go-related skills due to the 'whenever writing... Go code' trigger.
Suggestions
Add more concrete examples of specific modernizations performed (e.g., 'migrate to generics, adopt errors.Is/As, use slog structured logging, replace ioutil with io/os') to improve specificity.
Narrow the primary trigger from 'whenever writing, reviewing, or refactoring Go code' to focus more specifically on modernization contexts to reduce conflict risk with general Go coding skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (Golang code modernization) and mentions some actions like 'writing, reviewing, or refactoring Go code' and 'tooling modernization: linters, SAST, AI-powered code review in CI,' but it doesn't list multiple concrete specific actions (e.g., what specific modernizations it performs, which language features it targets). It stays at a moderate level of specificity. | 2 / 3 |
Completeness | Clearly answers both 'what' (modernize Golang code using latest language features, standard library improvements, idiomatic patterns, tooling modernization) and 'when' (writing/reviewing/refactoring Go code, when user asks about upgrades/migration/modernization/deprecation, when modernize linter reports issues, when old-style patterns are noticed). Explicit 'Use this skill whenever...' and 'Also use when...' clauses are present. | 3 / 3 |
Trigger Term Quality | Good coverage of natural trigger terms users would say: 'Go code', 'Go upgrades', 'migration', 'modernization', 'deprecation', 'modernize linter', 'refactoring', 'old-style Go patterns', 'linters', 'SAST', 'CI'. These are terms a user would naturally use when needing this skill. | 3 / 3 |
Distinctiveness Conflict Risk | While it's specific to Go modernization, the broad scope ('whenever writing, reviewing, or refactoring Go code') could overlap with a general Go coding skill or Go best practices skill. The modernization focus provides some distinction, but the trigger 'whenever writing... Go code' is very broad and could conflict with other Go-related skills. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
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, excellent prioritization framework, and good use of tables for quick reference. Its main weaknesses are the lack of inline executable code examples (deferred entirely to reference files that aren't provided in the bundle) and some verbosity in the introductory sections. The workflow and priority guide are the strongest elements, providing clear sequencing and decision-making frameworks.
Suggestions
Add 2-3 inline before/after code examples for the highest-priority modernizations (e.g., loop variable fix, math/rand/v2 migration) directly in SKILL.md so the skill is actionable without requiring reference files.
Tighten the opening sections — the scope paragraph and the modes description overlap with the workflow section; consolidate to reduce redundancy.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient but includes some unnecessary verbosity — the scope paragraph explaining what's included/excluded is overly detailed, and the persona/modes section at the top could be tighter. The deprecated packages table and priority guide are well-structured and earn their tokens, but the workflow section has some redundancy with the modes description. | 2 / 3 |
Actionability | The skill provides concrete workflow steps, a useful deprecated packages table, and a clear priority guide, but lacks executable before/after code examples directly in the SKILL.md — those are deferred to references/versions.md. The workflow steps are specific (check go.mod, run golangci-lint, write to .modernize) but without inline code snippets showing actual transformations, it's more directive than copy-paste ready. | 2 / 3 |
Workflow Clarity | The workflow is clearly sequenced with 9 explicit steps, includes validation checkpoints (run tests before dependency updates, check .modernize before suggesting), has a feedback loop (developer can ignore suggestions which get recorded), and the priority guide provides clear ordering. The dual-mode operation (inline vs full-scan) is well-defined with explicit triggers. | 3 / 3 |
Progressive Disclosure | The skill references two detailed files (references/versions.md and references/tooling.md) with clear signaling, and references related skills appropriately. However, no bundle files were provided to verify these references exist, and the main SKILL.md still contains substantial inline content (deprecated packages table, full priority guide) that could arguably live in reference files, making the balance between overview and detail slightly off. | 2 / 3 |
Total | 9 / 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.
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
e9761db
- 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.