Modernize Your Go Code with the New go fix Command

The Go 1.26 release brings a fully rewritten go fix subcommand, designed to automatically modernize your code by leveraging newer language and library features. This tool helps you transition from older patterns—like explicit loops or interface{}—to more concise and idiomatic alternatives. Below we answer common questions about using go fix effectively in your projects.

What is the go fix command and why was it rewritten?

go fix is a built‑in command that applies a suite of automated analysis and transformation fixes to your Go source files. In Go 1.26 it was completely rewritten to be faster, more reliable, and extensible. The new version focuses on identifying opportunities to improve code—for example, replacing interface{} with any, simplifying loop variables, or using the maps package instead of manual map iteration. The rewrite also introduces a clearer architecture for third‑party analyzers, making it easier for module maintainers and organizations to encode their own best practices.

Modernize Your Go Code with the New go fix Command — Source: blog.golang.org

How do I run go fix on my project?

Running go fix is straightforward. Like go build or go vet, it accepts package patterns. To fix all packages beneath your current directory, execute:

$ go fix ./...

On success, the command silently updates your source files in place. It is best to start from a clean git state before running go fix, so that the changes consist only of the tool’s edits—this makes code reviews much easier. We recommend running go fix every time you upgrade to a newer Go toolchain release, as new fixers are added with each version.

How can I preview changes before applying them?

To see what go fix would change without modifying your files, use the -diff flag:

$ go fix -diff ./...

This prints a unified diff of the proposed modifications to standard output. For example, it might show replacing a manual strings.IndexByte and slicing pattern with the simpler strings.Cut call:

--- dir/file.go (old)
+++ dir/file.go (new)
-                       eq := strings.IndexByte(pair, '=')
-                       result[pair[:eq]] = pair[1+eq:]
+                       before, after, _ := strings.Cut(pair, "=")
+                       result[before] = after

This diff lets you verify each fix before committing.

How do I list available fixers and get help?

You can list all registered fixers by running:

$ go tool fix help

This outputs a list similar to:

any – replace interface{} with any
buildtag – check //go:build and // +build directives
fmtappendf – replace []byte(fmt.Sprintf) with fmt.Appendf
forvar – remove redundant re‑declaration of loop variables
hostport – check address formats passed to net.Dial
inline – apply fixes based on //go:fix inline comment directives
mapsloop – replace explicit loops over maps with calls to maps package
minmax – replace if/else statements with calls to min or max

To see detailed documentation for a specific analyzer, append its name, e.g. $ go tool fix help forvar.

Can you give an example of a fixer in action?

Certainly! The forvar fixer cleans up redundant re‑declaration of loop variables. Before Go 1.22, it was common to write:

for _, v := range slice {
    v := v   // shadow to avoid closure issues
    go func() { fmt.Println(v) }()
}

Starting with Go 1.22, loop variables have per‑iteration scoping, so the shadowing is no longer necessary. The forvar fixer removes that unnecessary line. Another example is the any fixer, which replaces interface{} with the more concise any alias wherever it appears. Each fixer is carefully designed to be safe and preserve the exact semantics of your original code.

What happens to generated files?

go fix automatically skips any file that is recognized as generated (e.g., marked with the standard // Code generated comment). The rationale is that the correct place to fix generated code is in the generator itself, not in its output. If you need to update generated files, you should update the generator tool and regenerate them. This ensures that your codebase remains consistent and that upstream fixes are properly propagated.

When should I run go fix?

It is good practice to run go fix ./... over your project each time you update your Go toolchain to a newer release. New fixers are added in every major Go version (e.g., 1.26 brings many new analyzers), so running the command regularly keeps your code modern and aligned with current idioms. Since the command may touch hundreds of files, starting from a clean Git state is recommended. Your code reviewers will thank you—the only changes in your diff will be the ones go fix made, making the review quick and predictable.