golang-context
Idiomatic context.Context usage in Golang — creation, propagation, cancellation, timeouts, deadlines, context values, and cross-service tracing. Apply when working with context.Context in any Go code.
83
81%
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 a strong skill description that clearly identifies a specific Go language construct, enumerates concrete capabilities, and includes an explicit 'Apply when' trigger clause. The natural keywords cover the domain well and the niche is distinct enough to avoid conflicts with other Go-related skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: creation, propagation, cancellation, timeouts, deadlines, context values, and cross-service tracing. These are all distinct, concrete aspects of context.Context usage. | 3 / 3 |
Completeness | Clearly answers both what ('Idiomatic context.Context usage — creation, propagation, cancellation, timeouts, deadlines, context values, and cross-service tracing') and when ('Apply when working with context.Context in any Go code') with an explicit trigger clause. | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords users would say: 'context.Context', 'Golang', 'Go code', 'cancellation', 'timeouts', 'deadlines', 'context values', 'tracing'. These cover the natural terms a developer would use when asking about Go context patterns. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — targets a very specific Go language construct (context.Context) with clear, niche triggers. Unlikely to conflict with general Go skills or other language skills due to the precise scoping to context.Context. | 3 / 3 |
Total | 12 / 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 reasonably well-structured skill that covers Go context.Context conventions with clear organization and good use of progressive disclosure patterns. Its main weaknesses are: the introductory explanation is unnecessary for Claude, most best practices lack accompanying code examples (deferring to reference files that aren't provided), and the deep dive descriptions are verbose for what should be navigation signposts.
Suggestions
Remove the introductory paragraph explaining what context.Context is — Claude already knows this. Jump straight to the best practices.
Add executable code examples for the most critical best practices (e.g., WithCancel/defer cancel pattern, unexported context key type, WithTimeout usage) rather than deferring all code to reference files.
Trim the deep dive descriptions to one-line signposts (e.g., '**[Cancellation](./references/cancellation.md)** — WithCancel, WithTimeout, WithDeadline, AfterFunc, WithoutCancel patterns') instead of multi-line summaries.
Provide the referenced bundle files (references/cancellation.md, references/values-tracing.md, references/http-services.md) so the progressive disclosure structure is complete and verifiable.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The introductory sentence explaining what context.Context is ('Go's mechanism for propagating cancellation signals...') is unnecessary — Claude already knows this. The 'Think of it as the session of a request' metaphor is also padding. The best practices list and table are efficient, but the deep dive descriptions are somewhat verbose, restating what the reference files cover rather than just linking. | 2 / 3 |
Actionability | The skill provides one concrete code example (good vs bad propagation) and a useful reference table, but most of the 11 best practices are stated as rules without executable examples. Key patterns like WithCancel/WithTimeout usage, context value key types, and WithoutCancel are mentioned but not demonstrated with code — the actual executable guidance is deferred to reference files that aren't provided in the bundle. | 2 / 3 |
Workflow Clarity | For this type of skill (best practices/conventions rather than a multi-step destructive process), the workflow is appropriately clear. The numbered best practices provide an unambiguous sequence of rules, the table maps situations to actions, and the propagation principle is clearly stated with a concrete good/bad example. No destructive or batch operations require validation checkpoints. | 3 / 3 |
Progressive Disclosure | The structure is well-organized with a summary, table, example, deep dives, and cross-references — a good pattern. However, the three referenced deep-dive files (./references/cancellation.md, ./references/values-tracing.md, ./references/http-services.md) are not provided in the bundle, making it impossible to verify they exist or contain the promised content. The deep dive descriptions are also somewhat verbose inline summaries rather than brief signposts. | 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.