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 evaluation dimensions strongly. It lists specific concrete actions and tools, includes abundant natural trigger terms, explicitly states both what the skill does and when to use it, and even disambiguates itself from a closely related skill. The description is comprehensive without being padded or verbose.
| 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 with specific tools) and 'when' (explicit 'Use when...' clause listing six distinct trigger scenarios). Also clarifies boundary with the related golang-performance skill, which further aids selection. | 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', 'performance', 'Go benchmarks', 'hot paths'. These are terms developers naturally use when seeking help with Go performance measurement. | 3 / 3 |
Distinctiveness Conflict Risk | Clearly carves out a distinct niche focused on measurement and profiling methodology, and explicitly differentiates itself from the related 'golang-performance' skill by stating this skill handles measurement while the other handles optimization patterns. The specific tool names (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 strong, well-structured skill that covers the full Go benchmarking workflow with executable examples, clear sequencing, and excellent progressive disclosure to reference files. The main weakness is some verbosity in the Reference Files descriptions and minor over-explanation of concepts (like why b.Loop() prevents dead code elimination), though these are relatively minor issues. The commit documentation section with its explicit rules is a particularly valuable addition that goes beyond typical benchmarking guides.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The core content is mostly 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 file, which could be condensed significantly. The persona/thinking mode preamble and some explanatory text (e.g., explaining why b.Loop() prevents compiler optimization) add tokens that a capable model may not need. | 2 / 3 |
Actionability | Provides fully executable code examples for writing benchmarks (b.Loop, sub-benchmarks, memory tracking), running them (complete CLI flags with a reference table), profiling (exact commands for CPU/memory/trace), and documenting results (concrete commit format with benchstat output). Every section gives copy-paste ready commands and code. | 3 / 3 |
Workflow Clarity | The skill presents a clear end-to-end workflow: write benchmark → run with statistical rigor (-count=10) → profile → compare with benchstat → document in commits → detect regressions in CI. The commit documentation section includes explicit validation rules (never paste results with '~', only include affected benchmarks, include hardware context). The profiling section sequences CPU → memory → trace with specific commands. | 3 / 3 |
Progressive Disclosure | Excellent structure: the main SKILL.md provides a concise overview with executable quick-start content, then clearly signals 8 reference files with one-sentence descriptions of when to use each. Cross-references to related skills are well-organized. All references are one level deep with clear navigation paths. However, bundle files weren't provided so actual reference content can't be verified. | 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
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.