Mastering Go Fix: A Complete Guide to Automating Code Modernization

Overview

The Go ecosystem evolves rapidly, and with each release new language features, library improvements, and best practices emerge. Keeping your codebase up-to-date manually is tedious and error-prone. Enter go fix — a powerful command-line tool that automatically modernizes your Go source files. In Go 1.26, the go fix subcommand was completely rewritten, offering a suite of intelligent fixers that identify and apply improvements, often leveraging newer language constructs and standard library functions.

This guide walks you through everything you need to know: from running basic fixes to understanding each fixer, previewing changes, and integrating go fix into your development workflow. Whether you're a solo developer or part of a large team, mastering go fix will save you hours of manual refactoring and help your codebase stay modern.

Prerequisites

Go Version 1.26 or Later

The new go fix is only available in Go 1.26 and newer. Upgrade your toolchain if you haven't already. You can check your version with:

$ go version

A Clean Git State (Recommended)

Before running any automated fix, ensure your working directory is clean. Run:

$ git status

This allows you to easily review the changes go fix makes. If something goes wrong, you can revert with git checkout ..

Basic Familiarity with Go Modules

Understanding how packages and module patterns work will help you target specific code areas. The go fix command accepts the same patterns as go build and go vet.

Step-by-Step Instructions

Running Basic Fix

The simplest way to modernize your entire project is by running:

$ go fix ./...

This command recursively processes all packages under the current directory. On success, it silently updates your source files in place. It intelligently skips generated files (those with a // Code generated comment) because fixing those should be done in the generator itself.

Tip: Run this command every time you update to a newer Go toolchain release. Since it might fix hundreds of files, starting from a clean git state is crucial for code review clarity.

Previewing Changes with -diff

Before applying fixes, you can see what would change using the -diff flag:

$ go fix -diff ./...

This prints unified diffs to standard output. For example, you might see:

--- 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

The diff shows how go fix replaces a manual split with the cleaner strings.Cut function. Always review diffs to understand what each fixer does — especially before committing.

Listing Available Fixers

To see all registered fixers and their descriptions, run:

$ go tool fix help

This outputs a list similar to:

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
    …

Each fixer has a distinct purpose. For complete documentation on a specific fixer, use:

$ go tool fix help forvar

Using Individual Fixers

You can apply only certain fixers by specifying them with the -fix flag. For example, to run only the any and forvar fixers:

$ go fix -fix any,forvar ./...

This is useful when you want to gradually adopt modernizations, or when you want to avoid certain changes. You can also combine fixers as needed.

Integrating into Your Workflow

To make modernization a habit, add go fix to your CI pipeline or run it as part of a pre-commit hook. For example, a simple Makefile target:

.PHONY: modernize
modernize:
	go fix ./...
	go vet ./...

This ensures every merge request includes the latest automated improvements. Remember to commit the changes with a descriptive message like "chore: apply go fix modernizations".

Common Mistakes

• Running without a clean git state: Always commit or stash your changes first. Otherwise, it's hard to separate the fixer's edits from your own.
• Ignoring the -diff flag: Not previewing changes can lead to surprises. Especially for large codebases, always diff before applying.
• Applying all fixers blindly: Some fixers change behavior in subtle ways (e.g., hostport can complain about address formats). Understand each fixer's purpose before running them all together.
• Not updating generated code: If you have code generators, run go fix on the generator itself rather than the generated output. Otherwise, your fixes will be overwritten next time you generate.
• Forgetting to commit after fixing: The fixer modifies files silently. If you don't commit, subsequent work may be harder to review.
• Using an older Go version: The rewritten go fix is only in Go 1.26+. Using an older version gives you a different, less capable tool.

Summary

go fix is your automated assistant for keeping Go code modern. With a single command you can replace deprecated constructs, adopt new syntax (like any or min/max), and fix common issues like loop variable shadowing. Preview changes with -diff, selectively run fixers, and integrate the command into your regular development cycle. By making go fix part of every toolchain upgrade, you ensure your codebase stays clean, idiomatic, and performant with minimal manual effort.