Modernize Your Go Code with go fix: A Q&A Guide

The go fix command, revamped in Go 1.26, is a powerful tool for automatically modernizing your Go codebase. It applies a suite of analyzers that identify outdated patterns and replace them with more idiomatic, efficient, and modern equivalents—saving you hours of manual refactoring. This Q&A covers everything from running the command to understanding its internal machinery and extending it for your own guidelines.

What exactly does go fix do for my code?

go fix scans your Go source files and applies a series of built-in analyzers to detect opportunities for improvement. For example, it can replace interface{} with any, convert explicit loop iterations over maps to calls to the maps package, or replace if/else patterns with min and max functions. Each fixer is designed to take advantage of modern language features or libraries introduced in recent Go releases. The command runs silently on success, updating files in place while skipping generated code (since that should be fixed at the generator level). Running it after upgrading to a newer Go toolchain is highly recommended to keep your codebase aligned with current best practices.

How do I run go fix on my project?

The command follows the same pattern as go build or go vet. To fix all packages beneath the current directory, simply run:

$ go fix ./...

This updates your source files directly, so it's wise to start from a clean Git state—that way your commit contains only the changes made by go fix, making code review straightforward. If you prefer to examine changes before applying them, use the -diff flag as described in the next question. The command handles all packages in the given patterns, and it will skip any file it considers generated (based on the usual Go conventions).

Can I preview what go fix will change without applying it?

Absolutely. Use the -diff flag to see a unified diff of the proposed changes:

$ go fix -diff ./...

This prints the diff to the terminal without modifying any files. For example, it might show:

--- 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 is especially useful when you want to review each fix before committing, or when integrating go fix into a CI pipeline to check for potential issues without altering the codebase.

How do I see which fixers are available and get details about them?

To list all registered analyzers (fixers), run:

$ go tool fix help

This outputs a list like:

Registered analyzers:
    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 format of addresses 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
...

For complete documentation of a specific analyzer, add its name to the help command, for instance:

$ go tool fix help forvar

This shows a detailed description, including the problem it solves and the transformation it applies.

What are some real-world examples of code modernization with go fix?

go fix tackles a variety of outdated patterns. One common fix is replacing interface{} with the shorthand any (available since Go 1.18). Another converts manual string splitting using strings.IndexByte and slicing to the cleaner strings.Cut call. The forvar analyzer removes unnecessary shadowing of loop variables, a pattern that was common before Go 1.22 introduced per-iteration variables. The mapsloop fixer replaces explicit for k, v := range m { ... } patterns with calls to maps.Keys, maps.Values, or maps.Clone when appropriate. Each fixer is designed to produce more maintainable and idiomatic Go without changing the program's behavior.

When should I run go fix and what are the best practices?

The official recommendation is to run go fix ./... every time you upgrade to a newer Go toolchain release. This ensures your code stays up-to-date with language improvements and library deprecations. Always commit or stash your current changes first so that the diff contains only the automatic fixes. If you're working in a team, integrate go fix into your CI pipeline to catch outdated patterns early. For modules that use generated code, remember that go fix automatically skips generated files; any necessary fixes there should be applied to the generator itself. Finally, use the -diff flag during code review to show reviewers exactly what changed.

How is go fix evolving and can I create my own fixers?

The Go team has rearchitected go fix to be more extensible. Beyond the built-in analyzers, there is a growing theme of self-service analysis tools. Module maintainers and organizations can encode their own guidelines and best practices into custom analyzers that go fix can then apply. While the current release focuses on built-in fixes, the infrastructure supports future customization. This means you could develop internal fixers for code style rules, migration patterns, or API deprecations specific to your project. The command's modular design also makes it easier to add new analyzers over time, ensuring go fix remains a valuable tool for keeping Go codebases modern.