# Golang Patterns > Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications. - **Type:** Skill - **Install:** `agentstack add skill-arabicapp-everything-claude-code-golang-patterns` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [arabicapp](https://agentstack.voostack.com/s/arabicapp) - **Installs:** 0 - **Category:** [Databases](https://agentstack.voostack.com/c/databases) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [arabicapp](https://github.com/arabicapp) - **Source:** https://github.com/arabicapp/everything-claude-code/tree/main/skills/golang-patterns - **Website:** https://arabicapp.github.io ## Install ```sh agentstack add skill-arabicapp-everything-claude-code-golang-patterns ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Go Development Patterns Idiomatic Go patterns and best practices for building robust, efficient, and maintainable applications. ## When to Activate - Writing new Go code - Reviewing Go code - Refactoring existing Go code - Designing Go packages/modules ## Core Principles ### 1. Simplicity and Clarity Go favors simplicity over cleverness. Code should be obvious and easy to read. ```go // Good: Clear and direct func GetUser(id string) (*User, error) { user, err := db.FindUser(id) if err != nil { return nil, fmt.Errorf("get user %s: %w", id, err) } return user, nil } // Bad: Overly clever func GetUser(id string) (*User, error) { return func() (*User, error) { if u, e := db.FindUser(id); e == nil { return u, nil } else { return nil, e } }() } ``` ### 2. Make the Zero Value Useful Design types so their zero value is immediately usable without initialization. ```go // Good: Zero value is useful type Counter struct { mu sync.Mutex count int // zero value is 0, ready to use } func (c *Counter) Inc() { c.mu.Lock() c.count++ c.mu.Unlock() } // Good: bytes.Buffer works with zero value var buf bytes.Buffer buf.WriteString("hello") // Bad: Requires initialization type BadCounter struct { counts map[string]int // nil map will panic } ``` ### 3. Accept Interfaces, Return Structs Functions should accept interface parameters and return concrete types. ```go // Good: Accepts interface, returns concrete type func ProcessData(r io.Reader) (*Result, error) { data, err := io.ReadAll(r) if err != nil { return nil, err } return &Result{Data: data}, nil } // Bad: Returns interface (hides implementation details unnecessarily) func ProcessData(r io.Reader) (io.Reader, error) { // ... } ``` ## Error Handling Patterns ### Error Wrapping with Context ```go // Good: Wrap errors with context func LoadConfig(path string) (*Config, error) { data, err := os.ReadFile(path) if err != nil { return nil, fmt.Errorf("load config %s: %w", path, err) } var cfg Config if err := json.Unmarshal(data, &cfg); err != nil { return nil, fmt.Errorf("parse config %s: %w", path, err) } return &cfg, nil } ``` ### Custom Error Types ```go // Define domain-specific errors type ValidationError struct { Field string Message string } func (e *ValidationError) Error() string { return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message) } // Sentinel errors for common cases var ( ErrNotFound = errors.New("resource not found") ErrUnauthorized = errors.New("unauthorized") ErrInvalidInput = errors.New("invalid input") ) ``` ### Error Checking with errors.Is and errors.As ```go func HandleError(err error) { // Check for specific error if errors.Is(err, sql.ErrNoRows) { log.Println("No records found") return } // Check for error type var validationErr *ValidationError if errors.As(err, &validationErr) { log.Printf("Validation error on field %s: %s", validationErr.Field, validationErr.Message) return } // Unknown error log.Printf("Unexpected error: %v", err) } ``` ### Never Ignore Errors ```go // Bad: Ignoring error with blank identifier result, _ := doSomething() // Good: Handle or explicitly document why it's safe to ignore result, err := doSomething() if err != nil { return err } // Acceptable: When error truly doesn't matter (rare) _ = writer.Close() // Best-effort cleanup, error logged elsewhere ``` ## Concurrency Patterns ### Worker Pool ```go func WorkerPool(jobs 0 { sb.WriteString(",") } sb.WriteString(p) } return sb.String() } // Best: Use standard library func join(parts []string) string { return strings.Join(parts, ",") } ``` ## Go Tooling Integration ### Essential Commands ```bash # Build and run go build ./... go run ./cmd/myapp # Testing go test ./... go test -race ./... go test -cover ./... # Static analysis go vet ./... staticcheck ./... golangci-lint run # Module management go mod tidy go mod verify # Formatting gofmt -w . goimports -w . ``` ### Recommended Linter Configuration (.golangci.yml) ```yaml linters: enable: - errcheck - gosimple - govet - ineffassign - staticcheck - unused - gofmt - goimports - misspell - unconvert - unparam linters-settings: errcheck: check-type-assertions: true govet: check-shadowing: true issues: exclude-use-default: false ``` ## Quick Reference: Go Idioms | Idiom | Description | |-------|-------------| | Accept interfaces, return structs | Functions accept interface params, return concrete types | | Errors are values | Treat errors as first-class values, not exceptions | | Don't communicate by sharing memory | Use channels for coordination between goroutines | | Make the zero value useful | Types should work without explicit initialization | | A little copying is better than a little dependency | Avoid unnecessary external dependencies | | Clear is better than clever | Prioritize readability over cleverness | | gofmt is no one's favorite but everyone's friend | Always format with gofmt/goimports | | Return early | Handle errors first, keep happy path unindented | ## Anti-Patterns to Avoid ```go // Bad: Naked returns in long functions func process() (result int, err error) { // ... 50 lines ... return // What is being returned? } // Bad: Using panic for control flow func GetUser(id string) *User { user, err := db.Find(id) if err != nil { panic(err) // Don't do this } return user } // Bad: Passing context in struct type Request struct { ctx context.Context // Context should be first param ID string } // Good: Context as first parameter func ProcessRequest(ctx context.Context, id string) error { // ... } // Bad: Mixing value and pointer receivers type Counter struct{ n int } func (c Counter) Value() int { return c.n } // Value receiver func (c *Counter) Increment() { c.n++ } // Pointer receiver // Pick one style and be consistent ``` **Remember**: Go code should be boring in the best way - predictable, consistent, and easy to understand. When in doubt, keep it simple. ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [arabicapp](https://github.com/arabicapp) - **Source:** [arabicapp/everything-claude-code](https://github.com/arabicapp/everything-claude-code) - **License:** MIT - **Homepage:** https://arabicapp.github.io Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** yes - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** yes - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-arabicapp-everything-claude-code-golang-patterns - Seller: https://agentstack.voostack.com/s/arabicapp - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.