Golang Design Patterns

What it does

When your agent uses it

• Tasks that involve Design patterns

Example prompts

• “/golang-design-patterns”

Requirements

• 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, AskUserQuestion

Workflow steps

12 steps, taken from the first numbered list in SKILL.md.

1. 1Constructors SHOULD use functional options — they scale better as APIs evolve (one function per option, no breaking changes)
2. 2Functional options MUST return an error if validation can fail — catch bad config at construction, not at runtime
3. 3Avoid init() — runs implicitly, cannot return errors, makes testing unpredictable. Use explicit constructors
4. 4Enums SHOULD start at 1 (or Unknown sentinel at 0) — Go's zero value silently passes as the first enum member
5. 5Error cases MUST be handled first with early return — keep happy path flat
6. 6Panic is for bugs, not expected errors — callers can handle returned errors; panics crash the process
7. 7defer Close() immediately after opening — later code changes can accidentally skip cleanup
8. 8runtime.AddCleanup over runtime.SetFinalizer — finalizers are unpredictable and can resurrect objects
9. 9Every external call SHOULD have a timeout — a slow upstream hangs your goroutine indefinitely
10. 10Limit everything (pool sizes, queue depths, buffers) — unbounded resources grow until they crash
11. 11Retry logic MUST check context cancellation between attempts
12. 12Use strings.Builder for concatenation in loops → see samber/cc-skills-golang@golang-code-style

What it can do on your machine

Read from SKILL.md and the folder at commit 772edc7. 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
  • AskUserQuestion

  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 Design Patterns loads about 3k tokens when it runs, and up to ~11k if it reads all its reference files. Until then it costs about 202 tokens; SKILL.md has 982 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it

~202

When it runs · the whole SKILL.md, loaded when a task matches

~3k

With references · SKILL.md plus every file in references/, read only if the agent opens them

~11k

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

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 772edc7, republished under its MIT licence (© unxed). 982 words, ~2,983 tokens.

name

golang-design-patterns

description

Idiomatic Golang design patterns — functional options, constructor APIs, `init()` and global-state avoidance, enums, panic vs error decisions, resource management and lifecycle, graceful shutdown, timeouts and retries, streaming and iterators, and architecture styles (clean, hexagonal, DDD, flat). Apply when choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns, or asking which idiomatic Go pattern fits a specific problem. Not for wiring a DI container or comparing DI libraries (→ See `samber/cc-skills-golang@golang-dependency-injection` skill), nor for error wrapping, `errors.Is`/`As`, or logging mechanics (→ See `samber/cc-skills-golang@golang-error-handling` skill).

allowed-tools

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

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

type Server struct {
    addr         string
    readTimeout  time.Duration
    writeTimeout time.Duration
    maxConns     int
}

type Option func(*Server)

func WithReadTimeout(d time.Duration) Option {
    return func(s *Server) { s.readTimeout = d }
}

func WithWriteTimeout(d time.Duration) Option {
    return func(s *Server) { s.writeTimeout = d }
}

func WithMaxConns(n int) Option {
    return func(s *Server) { s.maxConns = n }
}

func NewServer(addr string, opts ...Option) *Server {
    // Default options
    s := &Server{
        addr:         addr,
        readTimeout:  5 * time.Second,
        writeTimeout: 10 * time.Second,
        maxConns:     100,
    }
    for _, opt := range opts {
        opt(s)
    }
    return s
}

// Usage
srv := NewServer(":8080",
    WithReadTimeout(30*time.Second),
    WithMaxConns(500),
)

// Bad — hidden global state
var db *sql.DB

func init() {
    var err error
    db, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        log.Fatal(err)
    }
}

// Good — explicit initialization, injectable
func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

type Status int

const (
    StatusUnknown Status = iota // 0 = invalid/unset
    StatusActive                // 1
    StatusInactive              // 2
    StatusSuspended             // 3
)

// Good — compiled once at package level
var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

func ValidateEmail(email string) bool {
    return emailRegex.MatchString(email)
}

import "embed"

//go:embed templates/*
var templateFS embed.FS

//go:embed version.txt
var version string

f, err := os.Open(path)
if err != nil {
    return err
}
defer f.Close() // right here, not 50 lines later

rows, err := db.QueryContext(ctx, query)
if err != nil {
    return err
}
defer rows.Close()

ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()

resp, err := httpClient.Do(req.WithContext(ctx))

© 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 7 other files (references) in .agents/skills/golang-design-patterns of unxed/f4.

• SKILL.md
• evals/evals.json
• references/architecture.md
• references/clean-architecture.md
• references/data-handling.md
• references/ddd.md
• references/hexagonal-architecture.md
• references/resource-management.md

Open the folder on GitHubat commit 772edc7

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.

• context-labs/whip.agents/skills/golang-design-patterns
• samber/cc-skills-golangskills/golang-design-patterns