go-patterns

name	go-patterns
description	Architecture patterns for MCP Toolkit Go code. Use this when writing or reviewing Go functions — composable design, error handling, and dependency injection.

Skill: Go Architecture Patterns

Composable Functions

Prefer small, composable functions with clear responsibilities:

func ConfigureServer(srv *Server, editor Editor) error {
    if err := validate(srv); err != nil {
        return fmt.Errorf("validation: %w", err)
    }
    return editor.WriteMCPConfig(srv)
}

Error Handling

Always wrap errors with context using fmt.Errorf and %w:

if err != nil {
    return fmt.Errorf("operation context: %w", err)
}

• Never ignore errors — handle or propagate every one.
• Wrap with enough context to trace the call chain.
• Use errors.Is() and errors.As() for checking wrapped errors.

Dependency Injection

Depend on interfaces, not concrete types:

type Runtime interface {
    Available() bool
    Name() string
}

func DetectRuntime(runtimes []Runtime) (Runtime, error) {
    for _, r := range runtimes {
        if r.Available() {
            return r, nil
        }
    }
    return nil, fmt.Errorf("no container runtime found")
}

Design Principles

• Single responsibility — each function and package does one thing.
• Open/closed — extend via interfaces, not modification.
• Interface segregation — small, focused interfaces (1–3 methods).
• Composition over inheritance — embed structs; avoid deep hierarchies.
• No global state — pass dependencies explicitly.