Google Go Style Guide

Official Google Go coding standards for idiomatic, maintainable code.

Golden Rules

1. Run gofmt before commit — formatting is non-negotiable
2. Short variable names in small scopes — i, err, ctx
3. Error handling, not exceptions — check every error
4. Interfaces for abstraction — accept interfaces, return structs
5. Defer for cleanup — ensure resources are released
6. Explicit is better — avoid magic, prefer clarity
7. Package names: lowercase, single word — no underscores

Quick Reference

Naming Conventions

Variables

// ✓ CORRECT - short names in small scopes
for i := 0; i < 10; i++ {
    // ...
}

// ✓ CORRECT - descriptive names in larger scopes
func ProcessUserData(userRepository UserRepository) error {
    // ...
}

// ✗ INCORRECT - unnecessarily long
for index := 0; index < 10; index++ {
    // ...
}

Error Handling

// ✓ CORRECT - check every error
user, err := getUser(id)
if err != nil {
    return nil, fmt.Errorf("failed to get user: %w", err)
}

// ✗ INCORRECT - ignoring errors
user, _ := getUser(id)

Functions

// ✓ CORRECT - multiple return values
func GetUser(id int) (*User, error) {
    // ...
}

// ✓ CORRECT - named return values for clarity
func ParseConfig(path string) (cfg *Config, err error) {
    // ...
}

Interfaces

// ✓ CORRECT - small, focused interfaces
type Reader interface {
    Read(p []byte) (n int, err error)
}

// ✓ CORRECT - accept interfaces, return structs
func ProcessData(r Reader) (*Result, error) {
    // ...
}

Defer

// ✓ CORRECT - defer for cleanup
func ReadFile(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    
    return io.ReadAll(f)
}

Goroutines and Channels

// ✓ CORRECT - use context for cancellation
func ProcessItems(ctx context.Context, items []Item) error {
    for _, item := range items {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            if err := process(item); err != nil {
                return err
            }
        }
    }
    return nil
}

// ✓ CORRECT - buffered channels when appropriate
results := make(chan Result, len(items))

Package Organization

// ✓ CORRECT - package comment
// Package user provides user management functionality.
package user

// ✓ CORRECT - group imports
import (
    "context"
    "fmt"
    
    "github.com/pkg/errors"
    
    "myapp/internal/db"
)

Common Mistakes

When to Use This Guide

• Writing new Go code
• Refactoring existing Go
• Code reviews
• Setting up linting rules (golangci-lint)
• Onboarding new team members

Install

npx skills add testdino-hq/google-styleguides-skills/go

Full Guide

See [go.md](go.md) for complete details, examples, and edge cases.