Mastering Go Fix: A Guide to Modernizing Your Codebase

Overview

With the release of Go 1.26, the go fix subcommand has been completely rewritten and now offers a powerful suite of analysis-driven transformations to help you modernize your code. Instead of just patching deprecated APIs, the new go fix can identify and apply improvements that leverage the latest language and library features—such as replacing interface{} with any, using strings.Cut instead of manual index parsing, or simplifying min/max logic with built-in functions. This guide walks you through everything you need to know to use go fix effectively, from basic usage to understanding the underlying analyzer infrastructure.

Whether you're maintaining a large monorepo or a handful of packages, integrating go fix into your update workflow saves time, reduces human error, and keeps your code base fresh. You’ll also learn how to preview changes, list available fixers, and even create your own self-service analysis rules.

Prerequisites

Before diving in, ensure you have the following:

• Go 1.26 or later – The rewritten go fix is only available starting with this version. Run go version to check your current toolchain. Download the latest release from the official download page if needed.
• A Go project to test on – Ideally a non‑critical project (or a separate branch) so you can safely experiment. Start with a clean git state so you can easily review and revert changes.
• Basic familiarity with the command line – Commands will be run in a terminal inside your project root.

Step‑by‑Step Instructions

1. Running go fix on Your Project

The simplest way to apply all available fixes to packages under the current directory is:

$ go fix ./...

This command silently updates your source files in place. It automatically skips generated files (those marked with a // Code generated comment), because the proper fix in that case would be to update the generator itself—not its output.

2. Previewing Changes with -diff

Before committing to modifications, you can see exactly what go fix would change by using the -diff flag:

$ go fix -diff ./...

This produces a unified diff output. For example, you might see something similar to:

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

Using -diff helps you build confidence in the tool’s changes and makes code review easier.

3. Listing Available Fixers

To see all the analyzers (fixes) that are bundled with go fix, run:

$ go tool fix help

This prints 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 analyzer has additional documentation. For example, to learn more about the forvar fix:

$ go tool fix help forvar

This explains that it removes unnecessary shadowing of loop variables that was common before Go 1.22.

4. Applying Only Specific Fixes

If you want to limit fixes to a particular analyzer, use the -fix flag followed by a comma‑separated list of analyzer names:

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

This applies only the any and minmax fixes, ignoring all others. This is useful when introducing changes incrementally.

5. Integrating Fixes Into Your Development Workflow

To keep your code continuously modernized, make running go fix ./... a standard step whenever you update your Go toolchain version. Here’s a recommended workflow:

1. Ensure your working tree is clean (git status shows no uncommitted changes).
2. Upgrade your Go toolchain (e.g., via go install golang.org/dl/go1.26.0@latest && go1.26.0 download).
3. Run go fix ./... in your project root.
4. Review the diff (using git diff after running without -diff) and commit the changes with a clear message like "all: apply go fix modernizations from Go 1.26".

Common Mistakes

Even with an automated tool, things can go awry. Here are pitfalls to avoid:

• Skipping code review – Never blindly apply fixes without reviewing the diff. Although go fix is generally safe, a generated transformation might change behavior in subtle ways (e.g., when a fix relies on the order of map iteration).
• Running on a dirty git state – Always start from a clean state. If you run go fix while you have uncommitted changes, the resulting diff will mix your pending work with automated edits, making it harder to separate and review.
• Assuming all fixes are applicable – Not every analyzer is relevant to your codebase. For example, the hostport fix only applies to code using net.Dial with incorrectly formatted addresses. If you don’t use that API, you can ignore it, but disabling unused analyzers with -fix reduces noise.
• Forgetting to update dependencies – Some fixes, like mapsloop, replace loops with calls to the maps package. Ensure your go.mod file already requires the necessary standard library packages (for 1.26 they are included by default, but if you’re using an older module, you may need to run go mod tidy).
• Overlooking generated files – While go fix skips generated files automatically, you might still want to update the generator code itself. If a fix like fmtappendf suggests changes to generated code, look upstream to fix the generator instead.

Summary

The rewritten go fix command in Go 1.26 is a powerful tool for automatically modernizing your codebase. By running go fix ./... after each toolchain upgrade, you can effortlessly adopt new language features (like any and min/max) and library improvements (such as strings.Cut and maps helpers). Remember to preview changes with -diff, selectively apply fixes with -fix, and always review the resulting diff before committing. Start using go fix today to keep your Go code clean, idiomatic, and up to date.