Golang Patterns

affaan-m/ECC/.kiro/skills/golang-patterns

by affaan-mef648e01899ba3e8dc6371642deaaf64b4477775No license275K starsListed Oct 9, 2026Updated Oct 9, 2026Repository updated 4 days ago

Go-specific design patterns and best practices including functional options, small interfaces, dependency injection, concurrency patterns, error handling, and package organization. Use when working with Go code to apply idiomatic Go patterns.

Instructions only

Go Patterns

This skill provides comprehensive Go patterns extending common design principles with Go-specific idioms.

Functional Options

Use the functional options pattern for flexible constructor configuration:

go
type Option func(*Server)
func WithPort(port int) Option {    return func(s *Server) { s.port = port }}
func NewServer(opts ...Option) *Server {    s := &Server{port: 8080}    for _, opt := range opts {        opt(s)    }    return s}

Benefits:

  • Backward compatible API evolution
  • Optional parameters with defaults
  • Self-documenting configuration

Small Interfaces

Define interfaces where they are used, not where they are implemented.

Principle: Accept interfaces, return structs

go
// Good: Small, focused interface defined at point of usetype UserStore interface {    GetUser(id string) (*User, error)}
func ProcessUser(store UserStore, id string) error {    user, err := store.GetUser(id)    // ...}

Benefits:

  • Easier testing and mocking
  • Loose coupling
  • Clear dependencies

Dependency Injection

Use constructor functions to inject dependencies:

go
func NewUserService(repo UserRepository, logger Logger) *UserService {    return &UserService{        repo:   repo,        logger: logger,    }}

Pattern:

  • Constructor functions (New* prefix)
  • Explicit dependencies as parameters
  • Return concrete types
  • Validate dependencies in constructor

Concurrency Patterns

Worker Pool

go
func workerPool(jobs <-chan Job, results chan<- Result, workers int) {    var wg sync.WaitGroup    for i := 0; i < workers; i++ {        wg.Add(1)        go func() {            defer wg.Done()            for job := range jobs {                results <- processJob(job)            }        }()    }    wg.Wait()    close(results)}

Context Propagation

Always pass context as first parameter:

go
func FetchUser(ctx context.Context, id string) (*User, error) {    // Check context cancellation    select {    case <-ctx.Done():        return nil, ctx.Err()    default:    }    // ... fetch logic}

Error Handling

Error Wrapping

go
if err != nil {    return fmt.Errorf("failed to fetch user %s: %w", id, err)}

Custom Errors

go
type ValidationError struct {    Field string    Msg   string}
func (e *ValidationError) Error() string {    return fmt.Sprintf("%s: %s", e.Field, e.Msg)}

Sentinel Errors

go
var (    ErrNotFound = errors.New("not found")    ErrInvalid  = errors.New("invalid input"))
// Check with errors.Isif errors.Is(err, ErrNotFound) {    // handle not found}

Package Organization

Structure

project/├── cmd/              # Main applications│   └── server/│       └── main.go├── internal/         # Private application code│   ├── domain/       # Business logic│   ├── handler/      # HTTP handlers│   └── repository/   # Data access└── pkg/              # Public libraries

Naming Conventions

  • Package names: lowercase, single word
  • Avoid stutter: user.User not user.UserModel
  • Use internal/ for private code
  • Keep main package minimal

Testing Patterns

Table-Driven Tests

go
func TestValidate(t *testing.T) {    tests := []struct {        name    string        input   string        wantErr bool    }{        {"valid", "[email protected]", false},        {"invalid", "not-an-email", true},    }
    for _, tt := range tests {        t.Run(tt.name, func(t *testing.T) {            err := Validate(tt.input)            if (err != nil) != tt.wantErr {                t.Errorf("got error %v, wantErr %v", err, tt.wantErr)            }        })    }}

Test Helpers

go
func testDB(t *testing.T) *sql.DB {    t.Helper()    db, err := sql.Open("sqlite3", ":memory:")    if err != nil {        t.Fatalf("failed to open test db: %v", err)    }    t.Cleanup(func() { db.Close() })    return db}

When to Use This Skill

  • Designing Go APIs and packages
  • Implementing concurrent systems
  • Structuring Go projects
  • Writing idiomatic Go code
  • Refactoring Go codebases

Source and attribution

Source:affaan-m/ECCin.kiro/skills/golang-patternsat commitef648e0

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

More from affaan-m/ECC

Unified Notifications Ops

affaan-m

Designs a unified notification policy that classifies, routes, deduplicates and escalates alerts across GitHub, Linear, hooks and chat.

Productivity & Workflow275Kupdated 4 days ago

Verification Loop

affaan-m

Runs a six-phase code verification loop and produces a PASS/FAIL readiness report.

Software Development275Kupdated 4 days ago

Ui To Vue

affaan-m

Converts batches of UI design screenshots into Vue 3 components using Vant, Element Plus, or Ant Design Vue.

Software Development275Kupdated 4 days ago

Unified Memory

affaan-m

Guides agents in sharing durable context and handoffs between harnesses through the local ECC Memory Vault.

AI & Agents275Kupdated 4 days ago

Visa Doc Translate

affaan-m

OCR-translates visa document images into English and produces a bilingual PDF with the original image and translation.

Documents & Office275Kupdated 4 days ago

Team Builder

affaan-m

Interactive picker that discovers agent personas, lets a user select up to five, runs them in parallel on one task, and synthesizes the results.

AI & Agents275Kupdated 4 days ago