Agent skill

Golang Naming

by unxed in unxed/f4

Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and…

MITAuto-check passedDevelopment

Install Golang Naming

skills CLI
$ npx skills add unxed/f4 --skill golang-naming -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install unxed/f4 golang-naming --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/unxed/f4.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/golang-naming .claude/skills/golang-naming && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
golang-naming
GitHub stars
244
Used in
2 other repos
Token cost
~3.1k tokens
SKILL.md length
1,229 words
Files
7 (incl. references)
Skills in repo
36
Repo updated
First seen
Licence
MIT

At a glance

Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and…

  • Writing new Go code
  • SKILL.md covers Quick Reference, MixedCaps, Avoid Stuttering and Frequently Missed Conventions, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Choosing between naming alternatives (New vs NewTypeName

What it does

Golang Naming is an agent skill from unxed/f4. Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and subtest names. Use this skill when writing new Go code, reviewing or refactoring, choosing between naming alternatives (New vs NewTypeName, isConnected vs connected, ErrNotFound vs NotFoundError, StatusReady vs StatusUnknown at iota 0), debating Go package names (utils/helpers anti-patterns), or asking about Go naming…

Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including reference files (for example `evals/evals.json`, `references/functions-methods.md` and `references/identifiers.md`). Compatibility notes: Designed for Claude Code, Codex or similar harness, and for projects using Golang.

It sits in Development, covering Refactoring. It works with Go. The repository describes itself as: dual pane like a charm. The licence is MIT.

When your agent uses it

  • Writing new Go code
  • Choosing between naming alternatives (New vs NewTypeName
  • IsConnected vs connected
  • ErrNotFound vs NotFoundError

Example prompts

  • “/golang-naming”

Requirements

  • Python 3
  • Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness, and for projects using Golang.
  • Pre-approved tools (allowed-tools): Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent

What it can do on your machine

Read from SKILL.md and the folder at commit 447642e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Edit
    • Write
    • Glob
    • Grep
    • Bash(go:*)
    • Bash(golangci-lint:*)
    • Bash(git:*)
    • Agent

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are go).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Designed for Claude Code, Codex or similar harness, and for projects using Golang.

    From compatibility in the SKILL.md frontmatter.

Context cost

Golang Naming loads about 3.1k tokens when it runs, and up to ~7.8k if it reads all its reference files. Until then it costs about 191 tokens; SKILL.md has 1,229 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~191
When it runs · the whole SKILL.md, loaded when a task matches
~3.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from unxed/f4 at commit 447642e, republished under its MIT licence (© unxed). 1,229 words, ~3,110 tokens.

Download SKILL.mdSave it as .claude/skills/golang-naming/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
golang-naming
description
Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and subtest names. Use this skill when writing new Go code, reviewing or refactoring, choosing between naming alternatives (New vs NewTypeName, isConnected vs connected, ErrNotFound vs NotFoundError, StatusReady vs StatusUnknown at iota 0), debating Go package names (utils/helpers anti-patterns), or asking about Go naming best practices. Also trigger when the user mentions MixedCaps vs snake_case, ALL_CAPS constants, Get-prefix on getters, or error string casing. Do NOT use for general Go implementation questions that don't involve naming decisions.
allowed-tools
Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent
compatibility
Designed for Claude Code, Codex or similar harness, and for projects using Golang.
user-invocable
true
license
MIT
metadata.author
samber
metadata.version
1.2.1
paths
**/*.go

Community default. A company skill that explicitly supersedes samber/cc-skills-golang@golang-naming skill takes precedence.

Go Naming Conventions

Go favors short, readable names. Capitalization controls visibility — uppercase is exported, lowercase is unexported. All identifiers MUST use MixedCaps, NEVER underscores.

"Clear is better than clever." — Go Proverbs

"Design the architecture, name the components, document the details." — Go Proverbs

To ignore a rule, just add a comment to the code.

Quick Reference

ElementConventionExample
Packagelowercase, single word, _test suffix OK for test filesjson, http, tabwriter, http_test
Filelowercase, underscores OKuser_handler.go
Exported nameUpperCamelCaseReadAll, HTTPClient
UnexportedlowerCamelCaseparseToken, userCount
Interfacemethod name + -erReader, Closer, Stringer
StructMixedCaps nounRequest, FileHeader
ConstantMixedCaps (not ALL_CAPS)MaxRetries, defaultTimeout
Receiver1-2 letter abbreviationfunc (s *Server), func (b *Buffer)
Error variableErr prefixErrNotFound, ErrTimeout
Error typeError suffixPathError, SyntaxError
ConstructorNew (single type) or NewTypeName (multi-type)ring.New, http.NewRequest
Boolean fieldis, has, can prefix on fields and methodsisReady, IsConnected()
Test functionTest + function nameTestParseToken
Acronymall caps or all lowerURL, HTTPServer, xmlParser
Variant: contextWithContext suffixFetchWithContext, QueryContext
Variant: in-placeIn suffixSortIn(), ReverseIn()
Variant: errorMust prefixMustParse(), MustLoadConfig()
Option funcWith + field nameWithPort(), WithLogger()
Enum (iota)type name prefix, zero-value = unknownStatusUnknown at 0, StatusReady
Named returndescriptive, for docs only(n int, err error)
Error stringlowercase (incl. acronyms), no punctuation"image: unknown format", "invalid id"
Import aliasshort, only on collisionmrand "math/rand", pb "app/proto"
Format funcf suffixErrorf, Wrapf, Logf
Test table fieldsgot/expected prefixesinput string, expected int

MixedCaps

All Go identifiers MUST use MixedCaps (or mixedCaps). NEVER use underscores in identifiers — the only exceptions are test function subcases (TestFoo_InvalidInput), generated code, and OS/cgo interop. This is load-bearing, not cosmetic — Go's export mechanism relies on capitalization, and tooling assumes MixedCaps throughout.

go
// ✓ Good
MaxPacketSize
userCount
parseHTTPResponse

// ✗ Bad — these conventions conflict with Go's export mechanism and tooling expectations
MAX_PACKET_SIZE   // C/Python style
max_packet_size   // snake_case
kMaxBufferSize    // Hungarian notation

Avoid Stuttering

Go call sites always include the package name, so repeating it in the identifier wastes the reader's time — http.HTTPClient forces parsing "HTTP" twice. A name MUST NOT repeat information already present in the package name, type name, or surrounding context.

go
// Good — clean at the call site
http.Client       // not http.HTTPClient
json.Decoder      // not json.JSONDecoder
user.New()        // not user.NewUser()
config.Parse()    // not config.ParseConfig()

// In package sqldb:
type Connection struct{}  // not DBConnection — "db" is already in the package name

// Anti-stutter applies to ALL exported types, not just the primary struct:
// In package dbpool:
type Pool struct{}        // not DBPool
type Status struct{}      // not PoolStatus — callers write dbpool.Status
type Option func(*Pool)   // not PoolOption

Frequently Missed Conventions

These conventions are correct but non-obvious — they are the most common source of naming mistakes:

Constructor naming: When a package exports a single primary type, the constructor is New(), not NewTypeName(). This avoids stuttering — callers write apiclient.New() not apiclient.NewClient(). Use NewTypeName() only when a package has multiple constructible types (like http.NewRequest, http.NewServeMux).

Boolean struct fields: Unexported boolean fields MUST use is/has/can prefix — isConnected, hasPermission, not bare connected or permission. The exported getter keeps the prefix: IsConnected() bool. This reads naturally as a question and distinguishes booleans from other types.

Error strings are fully lowercase — including acronyms. Write "invalid message id" not "invalid message ID", because error strings are often concatenated with other context (fmt.Errorf("parsing token: %w", err)) and mixed case looks wrong mid-sentence. Sentinel errors should include the package name as prefix: errors.New("apiclient: not found").

Enum zero values: Always place an explicit Unknown/Invalid sentinel at iota position 0. A var s Status silently becomes 0 — if that maps to a real state like StatusReady, code can behave as if a status was deliberately chosen when it wasn't.

Subtest names: Table-driven test case names in t.Run() should be fully lowercase descriptive phrases: "valid id", "empty input" — not "valid ID" or "Valid Input".

Detailed Categories

For complete rules, examples, and rationale, see:

  • Packages, Files & Import Aliasing — Package naming (single word, lowercase, no plurals), file naming conventions, import alias patterns (only use on collision to avoid cognitive load), and directory structure.

  • Variables, Booleans, Receivers & Acronyms — Scope-based naming (length matches scope: i for 3-line loops, longer names for package-level), single-letter receiver conventions (s for Server), acronym casing (URL not Url, HTTPServer not HttpServer), and boolean naming patterns (isReady, hasPrefix).

  • Functions, Methods & Options — Getter/setter patterns (Go omits Get so user.Name() reads naturally), constructor conventions (New or NewTypeName), named returns (for documentation only), format function suffixes (Errorf, Wrapf), and functional options (WithPort, WithLogger).

  • Types, Constants & Errors — Interface naming (Reader, Closer suffix with -er), struct naming (nouns, MixedCaps), constants (MixedCaps, not ALL_CAPS), enums (type name prefix like StatusReady), sentinel errors (ErrNotFound variables), error types (PathError suffix), and error message conventions (lowercase, no punctuation).

  • Test Naming — Test function naming (TestFunctionName), table-driven test field conventions (input, expected), test helper naming, and subcase naming patterns.

Show full SKILL.md (518 more words)Show less

Common Mistakes

MistakeFix
ALL_CAPS constantsGo reserves casing for visibility, not emphasis — use MixedCaps (MaxRetries)
GetName() getterGo omits Get because user.Name() reads naturally at call sites. But Is/Has/Can prefixes are kept for boolean predicates: IsHealthy() bool not Healthy() bool
Url, Http, Json acronymsMixed-case acronyms create ambiguity (HttpsUrl — is it Https+Url?). Use all caps or all lower
this or self receiverGo methods are called frequently — use 1-2 letter abbreviation (s for Server) to reduce visual noise
util, helper packagesThese names say nothing about content — use specific names that describe the abstraction
http.HTTPClient stutteringPackage name is always present at call site — http.Client avoids reading "HTTP" twice
user.NewUser() constructorSingle primary type uses New() — user.New() avoids repeating the type name
connected bool fieldBare adjective is ambiguous — use isConnected so the field reads as a true/false question
"invalid message ID" errorError strings must be fully lowercase including acronyms — "invalid message id"
StatusReady at iota 0Zero value should be a sentinel — StatusUnknown at 0 catches uninitialized values
"not found" error stringSentinel errors should include the package name — "mypackage: not found" identifies the origin
userSlice type-in-nameTypes encode implementation detail — users describes what it holds, not how
Inconsistent receiver namesSwitching names across methods of the same type confuses readers — use one name consistently
snake_case identifiersUnderscores conflict with Go's MixedCaps convention and tooling expectations — use mixedCaps
Long names for short scopesName length should match scope — i is fine for a 3-line loop, userIndex is noise
Naming constants by valueValues change, roles don't — DefaultPort survives a port change, Port8080 doesn't
FetchCtx() context variantWithContext is the standard Go suffix — FetchWithContext() is instantly recognizable
sort() in-place but no InReaders assume functions return new values. SortIn() signals mutation
parse() panicking on errorMustParse() warns callers that failure panics — surprises belong in the name
Mixing With*, Set*, Use*Consistency across the codebase — With* is the Go convention for functional options
Plural package namesGo convention is singular (net/url not net/urls) — keeps import paths consistent
Wrapf without f suffixThe f suffix signals format-string semantics — Wrapf, Errorf tell callers to pass format args
Unnecessary import aliasesAliases add cognitive load. Only alias on collision — mrand "math/rand"
Inconsistent concept namesUsing user/account/person for the same concept forces readers to track synonyms — pick one name

Applying these fixes means renaming existing identifiers — → See samber/cc-skills-golang@golang-gopls skill to do it safely: its rename updates every call site across the workspace and refuses a rename that would break interface satisfaction, which a grep/sed or manual Edit-based rename silently misses.

Enforce with Linters

Many naming convention issues are caught automatically by linters: revive, predeclared, misspell, errname. See samber/cc-skills-golang@golang-lint skill for configuration and usage.

Cross-References

  • → See samber/cc-skills-golang@golang-code-style skill for broader formatting and style decisions
  • → See samber/cc-skills-golang@golang-structs-interfaces skill for interface naming depth and receiver design
  • → See samber/cc-skills-golang@golang-lint skill for automated enforcement (revive, predeclared, misspell, errname)
  • → See samber/cc-skills-golang@golang-gopls skill for safe rename when applying a naming fix
  • → See samber/cc-skills-golang@golang-refactoring skill for how to apply a rename safely at scale (gopls Rename/Inline, blast-radius mapping, staged PR workflow) once you've decided what to rename identifiers to

© unxed, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (references) in .agents/skills/golang-naming of unxed/f4.

  • SKILL.md
  • evals/evals.json
  • references/functions-methods.md
  • references/identifiers.md
  • references/packages-files.md
  • references/testing.md
  • references/types-errors.md

Open the folder on GitHubat commit 447642e

Used in 2 other repositories

We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in unxed/f4, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Golang Naming next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Golang Naming compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Golang Naming this skillunxed/f42442 repos~3.1kAutomated safety check: PassMIT
GolangJanDeDobbeleer/oh-my-posh24k—~705Automated safety check: PassMIT
Valgocohesivestack/valgo508—~2.4kAutomated safety check: PassMIT
Typed Dependencies with fp-go EffectIBM/fp-go2k—~4.3kAutomated safety check: PassApache-2.0
Gograph Go Repository Intelligenceozgurcd/gograph229—~4.8kAutomated safety check: NotesMIT
Golang Dependency Injectionsamber/cc-skills-golang3.4k—~3.2kAutomated safety check: PassMIT

Similar skills

  • Golang

    JanDeDobbeleer/oh-my-posh

    Go conventions for this project that differ from common Go practice.

    24k GitHub stars~705 tokensUpdated today
    DevelopmentAuto-check passed
  • Valgo

    cohesivestack/valgo

    Add, refactor, debug, review, explain, or migrate type-safe validation in consumer Go applications using github.com/cohesivestack/valgo.

    508 GitHub stars~2.4k tokensUpdated 1 mo ago
    DevelopmentAuto-check passed
  • Teaches an agent to write fp-go v2 services with the Effect type, carrying dependencies in its type parameter instead of in context.Context or parameters.

    2k GitHub stars~4.3k tokensUpdated today
    DevelopmentAuto-check passed
  • Gives an agent working in a Go codebase a structural view through a local MCP server: call graphs, blast-radius and impact analysis, and bounded first-call exploration.

    229 GitHub stars~4.8k tokensUpdated today
    DevelopmentAuto-check: notes
  • Golang Dependency Injection

    samber/cc-skills-golang

    Comprehensive guide for dependency injection (DI) in Golang.

    3.4k GitHub stars~3.2k tokensUpdated 9 days ago
    DevelopmentAuto-check passed
  • Official

    Guides writing or reviewing point-free, first-match-wins case lists in fp-go v2 Go code instead of switch statements and if-else chains.

    2k GitHub stars~2.8k tokensUpdated today
    DevelopmentAuto-check passed

More from unxed/f4

All 36 skills in this repo
  • Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt.

    244 GitHub starsUsed in 3 repos~3.5k tokens
    Auto-check passed
  • Golang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt.

    244 GitHub starsUsed in 3 repos~2.5k tokens
    Auto-check passed
  • Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context…

    244 GitHub starsUsed in 2 repos~2.9k tokens
    Auto-check passed
  • Security audit checklist based on OWASP Top 10 and best practices.

    244 GitHub stars~5.4k tokensUpdated today
    Auto-check: notes
  • Golang concurrency design — goroutine lifecycle and leak prevention, channels and select, channel ownership and direction, sync.Mutex/RWMutex/sync.Map/sync.Once/atomics, errgroup, singleflight…

    244 GitHub starsUsed in 1 repo~2.4k tokens
    Auto-check passed
  • Production-ready Golang tests — table-driven tests, testify suites and mocks, parallel tests, fuzzing, fixtures, goroutine leak detection with goleak, snapshot testing, code coverage, integration…

    244 GitHub starsUsed in 1 repo~4.5k tokens
    Auto-check passed

Works with

Categories

Questions about Golang Naming

What does Golang Naming do?

Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and…. Golang Naming is an agent skill from unxed/f4. Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and subtest names.

When should I use Golang Naming?

Golang Naming fits situations like: writing new Go code; choosing between naming alternatives (New vs NewTypeName; isConnected vs connected; errNotFound vs NotFoundError.

How do I install Golang Naming in Claude Code?

Run `npx skills add unxed/f4 --skill golang-naming -a claude-code`. Or copy the skill folder (.agents/skills/golang-naming in unxed/f4) into .claude/skills/golang-naming in your project. Claude Code loads it when a task matches its description.

How do I install Golang Naming in Codex?

Run `npx skills add unxed/f4 --skill golang-naming -a codex`. Or copy the skill folder (.agents/skills/golang-naming in unxed/f4) into .agents/skills/golang-naming in your project. Codex loads it when a task matches its description.

Can I use Golang Naming in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add unxed/f4 --skill golang-naming -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/golang-naming, .gemini/skills/golang-naming, .github/skills/golang-naming and .opencode/skills/golang-naming in your project.

What does Golang Naming need to run?

SKILL.md names no scripts, command-line tools or credentials: Golang Naming is instructions for the agent only. Our summary lists: Python 3. Its frontmatter pre-approves these tools: Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent. Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness, and for projects using Golang..

Does Golang Naming access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Golang Naming safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Golang Naming use?

Golang Naming is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Golang Naming use?

About 3.1k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.7k tokens, read only when the agent opens those files.

What are the alternatives to Golang Naming?

Skills that share tags, products or a category with Golang Naming: Golang (JanDeDobbeleer/oh-my-posh, 24k stars), Valgo (cohesivestack/valgo, 508 stars), Typed Dependencies with fp-go Effect (IBM/fp-go, 2k stars) and Gograph Go Repository Intelligence (ozgurcd/gograph, 229 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Golang Naming?

unxed (a GitHub user) maintains it in unxed/f4, which has 244 GitHub stars. The repository holds 36 skills in this directory. The repository was last updated on October 10, 2026.

Source: unxed/f4 on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.