Stop Writing Go Like 2015: The Ultimate Modern Go Evolution Guide

Overview

Go’s compatibility promise allows code written for early versions (e.g., Go 1.4) to compile on Go 1.26, but many projects still use outdated patterns such as interface{}, manual slice searches, helper functions for pointers, and verbose Context initialization. JetBrains open‑sourced an AI coding Agent Skill use‑modern‑go that forces the model to generate code matching the go.mod version and to use the most modern, idiomatic standard‑library APIs.

Phase 1 – Early Code Cleanup (Go 1.0 – Go 1.19)

Time calculations

Replace manual subtraction with the built‑in helpers:

start := time.Now()
// do work
elapsed := time.Since(start)

deadline := time.Now().Add(5 * time.Second)
remaining := time.Until(deadline)

Error handling

Since Go 1.13 introduced error wrapping, compare errors with errors.Is instead of ==:

if errors.Is(err, sql.ErrNoRows) {
    // works even after %w wrapping
}

Replacing interface{} with any

Go 1.18 adds the alias any, allowing a cleaner signature:

func PrintAll(vals []any) { /* ... */ }

String splitting without panics

Use strings.Cut (Go 1.18) instead of strings.Index plus slicing:

if key, value, found := strings.Cut(header, ":"); found {
    // safe, one‑call solution
}

Zero‑allocation string building

Replace fmt.Sprintf with fmt.Appendf (Go 1.19) to avoid hidden heap allocations:

buf := []byte("Prefix: ")
buf = fmt.Appendf(buf, "user_id=%d", id) // zero‑alloc if capacity is enough

Typed atomic operations

Go 1.19 introduces generic atomic types, making code safer and more readable:

var flag atomic.Bool
flag.Store(true)
if flag.Load() { /* ... */ }

var cfg atomic.Pointer[Config]
cfg.Store(&Config{})

Phase 2 – Generic Renaissance (Go 1.20 – Go 1.21)

Cloning strings and bytes

When a small slice of a large string or byte slice is needed without retaining the whole backing array, use strings.Clone or bytes.Clone (Go 1.20):

copiedStr := strings.Clone(hugeString[:10])

Context cancellation causes

Go 1.20 adds context.WithCancelCause so the reason for cancellation is retained:

ctx, cancel := context.WithCancelCause(parent)
cancel(fmt.Errorf("db connection lost"))
err := context.Cause(ctx) // returns the original error

Built‑in helpers

Go 1.21 introduces min, max, and clear for concise operations:

m := max(a, b)          // works for any comparable type
clear(myMap)           // efficiently empties a map while keeping capacity

Slices and maps utilities

Replace manual loops with the slices and maps packages:

found := slices.Contains(items, target)
idx := slices.IndexFunc(users, func(u User) bool { return u.ID == 42 })
slices.Sort(ints)
clonedMap := maps.Clone(originalMap)

Single‑execution with return value

sync.OnceValue

(Go 1.21) combines sync.Once with a return value, removing the need for external variables and extra locks:

var GetConfig = sync.OnceValue(func() *Config { return loadConfig() })
cfg := GetConfig()

Phase 3 – Syntax Tweaks and Web Routing (Go 1.22)

Range‑only loops

Replace classic for i := 0; i < n; i++ with for i := range n:

for i := range 10 { /* ... */ }

Default value helper

cmp.Or

returns the first non‑zero value, simplifying environment‑variable handling:

port := cmp.Or(os.Getenv("PORT"), "8080")

Enhanced http.ServeMux

Go 1.22 adds method and path‑parameter support, reducing the need for third‑party routers:

mux := http.NewServeMux()
mux.HandleFunc("POST /api/users/{id}", func(w http.ResponseWriter, r *http.Request) {
    userID := r.PathValue("id")
    // ...
})

Phase 4 – The Iterator Era (Go 1.23 – Go 1.24)

Iterating over maps and slices

Go 1.23 introduces iter.Seq, unifying sequence traversal. The standard library now provides helpers for collecting and sorting keys:

keys := slices.Collect(maps.Keys(m))
sortedKeys := slices.Sorted(maps.Keys(m))

Testing and benchmarking modernisation

Use t.Context() for automatic cancellation and b.Loop() to prevent compiler optimisations (Go 1.24):

func TestFoo(t *testing.T) {
    ctx := t.Context()
    doSomething(ctx)
}

func BenchmarkBar(b *testing.B) {
    for b.Loop() {
        doWork()
    }
}

JSON struct tags

Go 1.24 adds the omitzero tag to omit zero‑value fields such as time.Time:

type User struct {
    CreatedAt time.Time `json:"created_at,omitzero"`
}

Zero‑allocation splitting

strings.SplitSeq

iterates without allocating a slice:

for part := range strings.SplitSeq(s, ",") { /* ... */ }

Phase 5 – The Future Is Now (Go 1.25 – Go 1.26)

WaitGroup helper

wg.Go()

(Go 1.25) automatically handles Add(1) and Done():

var wg sync.WaitGroup
for _, item := range items {
    wg.Go(func() { process(item) })
}
wg.Wait()

Expression‑based new

Go 1.26 allows new(expr) to infer pointer types, simplifying struct initialisation:

cfg := Config{
    Timeout: new(30),   // *int
    Debug:   new(true), // *bool
    Role:    new("admin"), // *string
}

Generic type‑safe error assertions

errors.AsType

(Go 1.26) removes the need for a pointer‑to‑pointer and provides compile‑time safety:

if pathErr, ok := errors.AsType[*os.PathError](err); ok {
    handle(pathErr)
}

Conclusion

From Go 1.0 to 1.26 the language has steadily eliminated boilerplate while preserving simplicity. The use‑modern‑go skill shows that, in the AI‑assisted era, large models can be guided to generate code that follows the latest best practices, keeping projects modern and efficient.