golang-samber-do
Implements dependency injection in Golang using samber/do. Apply this skill when working with dependency injection, setting up service containers, managing service lifecycles, or when you see code using github.com/samber/do/v2. Also use when refactoring manual dependency injection, implementing health checks, graceful shutdown, or organizing services into scopes/modules.
84
82%
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 clearly identifies the specific library (samber/do), language (Golang), and concrete use cases. It provides both a clear 'what' and comprehensive 'when' triggers, including both conceptual triggers (dependency injection, service lifecycles) and code-level triggers (github.com/samber/do/v2). The description is well-structured, uses third person voice, and is distinctive enough to avoid conflicts with other skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: implementing dependency injection, setting up service containers, managing service lifecycles, refactoring manual dependency injection, implementing health checks, graceful shutdown, and organizing services into scopes/modules. | 3 / 3 |
Completeness | Clearly answers both 'what' (implements dependency injection in Golang using samber/do) and 'when' with explicit triggers ('Apply this skill when working with dependency injection, setting up service containers... or when you see code using github.com/samber/do/v2'). | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms users would say: 'dependency injection', 'service containers', 'samber/do', 'github.com/samber/do/v2', 'health checks', 'graceful shutdown', 'scopes/modules', 'Golang'. These cover both the library-specific and conceptual terms a user would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive due to the specific library (samber/do), language (Golang), and narrow domain (dependency injection). The mention of the specific GitHub package path makes it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid, actionable skill with excellent executable code examples covering the full range of samber/do v2 usage. Its main weaknesses are moderate verbosity (explanatory rationale in best practices, persona block, some unnecessary context) and missing validation/error-recovery checkpoints in the workflow. The progressive disclosure structure is reasonable but cannot be fully verified without bundle files.
Suggestions
Trim the best practices rationale explanations to just the imperative guidance — Claude doesn't need to be told why interfaces help testing.
Add validation checkpoints: what to check after container setup (e.g., `injector.ListProvidedServices()` or health check invocation) and how to handle circular dependency errors.
Remove the persona block and the Context7 mention — these add tokens without actionable value.
Consider moving the quick reference tables to a separate reference file to keep the main skill leaner.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Generally efficient but has some unnecessary padding: the persona block, the note about Context7, explaining what lazy/eager/transient mean (Claude knows these patterns), and the best practices section includes rationale explanations that Claude doesn't need. The quick reference tables are useful but add length. | 2 / 3 |
Actionability | Provides fully executable, copy-paste-ready Go code examples for every major operation: registration, invocation, dependency chains, implicit aliasing, named services, package organization, and full application setup. The quick reference tables serve as a concrete lookup. | 3 / 3 |
Workflow Clarity | The numbered steps (1-5) in Basic Usage provide a clear sequence for setting up DI, and the Full Application Setup shows the composition pattern. However, there are no validation checkpoints or error recovery steps — e.g., no guidance on what to do when provider registration fails, circular dependencies occur, or shutdown errors happen. | 2 / 3 |
Progressive Disclosure | References to ./references/advanced.md and ./references/testing.md are well-signaled and one level deep, which is good. However, no bundle files were provided, so these references cannot be verified. The main file itself is fairly long with inline content (quick reference tables, full app setup) that could arguably be in reference files, and the cross-references at the bottom to other skills are helpful but add to the length. | 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.