golang-benchmark
Golang benchmarking, profiling, and performance measurement. Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof, interpreting CPU/memory/trace profiles, analyzing results with benchstat, setting up CI benchmark regression detection, or investigating production performance with Prometheus runtime metrics. Also use when the developer needs deep analysis on a specific performance indicator - this skill provides the measurement methodology, while golang-performance provides the optimization patterns.
92
92%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
100%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 an excellent skill description that covers all dimensions well. It lists specific concrete actions and tools, includes abundant natural trigger terms that Go developers would use, explicitly states both what it does and when to use it, and even proactively distinguishes itself from a closely related skill (golang-performance). The description is comprehensive without being padded or vague.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: writing/running/comparing benchmarks, profiling with pprof, interpreting CPU/memory/trace profiles, analyzing with benchstat, setting up CI benchmark regression detection, and investigating production performance with Prometheus runtime metrics. | 3 / 3 |
Completeness | Clearly answers both 'what' (benchmarking, profiling, performance measurement for Go) and 'when' with explicit triggers ('Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof...'). Also explicitly distinguishes itself from the related golang-performance skill by clarifying the boundary. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms users would say: 'benchmarking', 'profiling', 'pprof', 'CPU/memory/trace profiles', 'benchstat', 'CI benchmark regression', 'Prometheus runtime metrics', 'Go benchmarks', 'hot paths', 'performance measurement'. These are terms developers naturally use when seeking this kind of help. | 3 / 3 |
Distinctiveness Conflict Risk | Clearly carves out a distinct niche focused on measurement/profiling methodology for Go, and explicitly differentiates from the related 'golang-performance' skill by stating this skill handles measurement while the other handles optimization patterns. The specific tool references (pprof, benchstat, Prometheus) further reduce conflict risk. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
85%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 skill with strong actionability and excellent progressive disclosure. The main content provides executable examples for the core workflow (write, run, profile benchmarks) while deferring detailed reference material to clearly-signaled sub-files. The primary weakness is verbosity in the Reference Files section, where each entry has a multi-sentence description that could be trimmed, and the persona/thinking mode preamble adds tokens without proportional value.
Suggestions
Trim the Reference Files section — each bullet's description is 3-4 sentences when 1 sentence would suffice (e.g., '**[pprof Reference](./references/pprof.md)** — CLI commands, profile types, web UI, interpretation patterns').
Remove or shorten the persona and 'Thinking mode' preamble — Claude doesn't need to be told it's a 'performance measurement engineer' to follow the instructions.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The main body is reasonably efficient with good code examples and tables, but the Reference Files section is verbose — each bullet has a lengthy description explaining when to use each reference, which adds significant token cost. The persona and thinking mode preamble also add tokens without much actionable value. | 2 / 3 |
Actionability | Provides fully executable, copy-paste-ready code examples for writing benchmarks (b.Loop, sub-benchmarks, memory tracking), running them (complete CLI commands with flags), and profiling. The flag reference table and output format explanation are concrete and immediately usable. | 3 / 3 |
Workflow Clarity | The skill follows a clear sequential workflow: write benchmark → run benchmark → profile → compare with benchstat → track in CI. Each step has concrete commands. The cross-references to detailed reference files for each stage make the progression explicit. For a measurement skill, the workflow is well-sequenced with clear checkpoints (statistical rigor via -count=10, benchstat for comparison). | 3 / 3 |
Progressive Disclosure | Excellent progressive disclosure — the main file provides a concise overview with executable quick-start examples, then clearly signals 8 one-level-deep reference files with descriptive summaries explaining when to use each. Cross-references to related skills are well-organized at the bottom. | 3 / 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.
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
b88f91d
- 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.