golang-project-layout
Provides a guide for setting up Golang project layouts and workspaces. Use when starting a new Go project, organizing an existing codebase, setting up a monorepo with multiple packages, creating CLI tools with multiple main packages, deciding between cmd/internal/pkg directory conventions, or discussing package restructuring, package splits, or module splits.
63
76%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/golang-project-layout/SKILL.mdQuality
Discovery
89%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 with excellent trigger term coverage and completeness. The 'Use when...' clause is thorough and covers many realistic scenarios a user might encounter. The main weakness is that the core capability statement ('provides a guide') is somewhat generic rather than listing specific concrete actions the skill performs.
Suggestions
Replace 'Provides a guide for setting up' with more specific action verbs describing what the skill actually does, e.g., 'Generates directory structures, configures Go workspaces, scaffolds cmd/internal/pkg layouts for Golang projects.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (Golang project layouts and workspaces) and mentions some actions like 'setting up', 'organizing', 'creating CLI tools', but the core capability is described as 'provides a guide' which is somewhat vague rather than listing multiple concrete actions the skill performs. | 2 / 3 |
Completeness | Clearly answers both 'what' (provides a guide for setting up Golang project layouts and workspaces) and 'when' with an explicit 'Use when...' clause listing six specific trigger scenarios. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms users would say: 'Go project', 'monorepo', 'multiple packages', 'CLI tools', 'cmd/internal/pkg directory conventions', 'package restructuring', 'package splits', 'module splits'. These are highly natural keywords a Go developer would use. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with Go-specific terminology like 'cmd/internal/pkg directory conventions', 'monorepo', 'module splits'. This is unlikely to conflict with other skills due to its narrow focus on Go project structure specifically. | 3 / 3 |
Total | 11 / 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 project layout guide with a clear workflow (initialization checklist) and good use of progressive disclosure through references to other files and skills. Its main weaknesses are moderate verbosity in places (explaining concepts Claude knows, like 12-Factor basics) and heavy reliance on external references that aren't provided in the bundle, making the actionability dependent on files we can't verify exist. The skill would benefit from inlining at least one concrete directory tree example rather than deferring all examples to reference files.
Suggestions
Inline at least one concrete directory tree example (e.g., the 'small project' layout) directly in the SKILL.md rather than deferring all examples to references/directory-layouts.md, so the skill is actionable even without bundle files.
Trim the 12-Factor App section to just the reference link and a one-line reminder — Claude already knows these conventions and doesn't need them enumerated.
Ensure all referenced files (references/directory-layouts.md, assets/Makefile, etc.) are included in the bundle so the progressive disclosure structure actually works.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Generally efficient but includes some unnecessary framing (e.g., the persona statement, explaining what 12-Factor App is). The 'Ask First' and 'Ask Next' sections add process overhead that could be more concise. The module naming 'Bad' examples explain things Claude already knows. | 2 / 3 |
Actionability | The initialization checklist is concrete and actionable with specific commands (go mod init, gofmt). However, much of the guidance is directional rather than executable — it points to other skills and reference files rather than providing inline executable examples. The directory layout section describes conventions but defers actual examples to a reference file that isn't provided in the bundle. | 2 / 3 |
Workflow Clarity | The initialization checklist provides a clear, sequenced workflow for starting a new Go project with explicit steps. The 'Ask First' → 'Ask Next' → decide type → structure flow is well-ordered. For a project setup skill (not a destructive/batch operation), the checklist format with decision points is appropriate and sufficient. | 3 / 3 |
Progressive Disclosure | The skill references multiple external files (references/directory-layouts.md, references/config.md, references/testing-layout.md, references/workspaces.md, assets/Makefile, assets/.gitignore) and related skills, which is good structure. However, no bundle files were provided, so we cannot verify these references exist. The main content appropriately stays at overview level, but the heavy reliance on missing references means the skill is incomplete as a standalone document. | 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
8c7e016
- 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.