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.

Quality

76%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./skills/golang-project-layout/SKILL.md

Quality

Content

62%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill provides a well-structured overview of Go project layout decisions with a clear initialization workflow and good use of decision tables. Its main weakness is that much of the substantive content (directory layouts, config patterns, workspace setup) is delegated to reference files that aren't provided in the bundle, making the skill feel like a table of contents rather than a self-contained guide. The actionability suffers because the most critical details live in unreachable references.

Suggestions

Include the bundle reference files (especially references/directory-layouts.md) or inline the most critical directory layout examples directly in the SKILL.md so the core guidance is actionable without external files.

Trim explanatory text that Claude already knows (e.g., the 12-Factor App description can be reduced to just 'Follow 12-Factor App conventions' with a link) to improve conciseness.

Add at least one concrete, complete directory tree example inline (e.g., for a CLI tool or service) so the skill is immediately actionable without navigating to references.

Dimension	Reasoning	Score
Conciseness	Generally efficient but includes some unnecessary framing (e.g., the persona statement, explaining what 12-Factor App is). The module naming 'bad examples' section and some explanatory text could be tightened. However, most content earns its place.	2 / 3
Actionability	The initialization checklist provides concrete steps with specific commands (go mod init, gofmt), and the module naming section has concrete examples. However, much of the core guidance delegates to external references and other skills rather than providing executable code directly. The directory layout section describes conventions but defers actual examples to a reference file that isn't provided.	2 / 3
Workflow Clarity	The initialization checklist provides a clear, sequenced workflow with decision points ('Ask the developer' steps first, then structural decisions, then concrete setup commands). The 'Ask First' and 'Ask Next' sections establish a clear decision sequence. For a project setup skill, this level of workflow clarity is appropriate.	3 / 3
Progressive Disclosure	The skill references many external files (references/directory-layouts.md, references/config.md, references/testing-layout.md, references/workspaces.md, assets/Makefile, assets/.gitignore) and other skills, which is good structure. However, no bundle files were provided, meaning these references are unverifiable. The main content also delegates heavily — the directory layout section, which is arguably the core of a 'project layout' skill, is almost entirely deferred to a reference file.	2 / 3
	Total	9 / 12 Passed

Description

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 with multiple specific scenarios. The main weakness is that the core capability statement ('provides a guide') is somewhat generic rather than listing concrete actions the skill performs (e.g., 'generates directory structures, configures go.work files, creates module layouts').

Suggestions

Replace 'Provides a guide for setting up' with more concrete action verbs describing what the skill actually does, e.g., 'Generates directory structures, configures Go workspaces, and recommends package organization 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

Validation

81%

Warnings & errors only

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: a5e0e59

Reviewed: 14 days ago

Table of Contents

Discovery Implementation Validation

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.