Modernizing Go Codebases with the Enhanced go fix Command

Introduction

The Go 1.26 release ships with a completely redesigned go fix subcommand, transforming it from a simple one-shot migration tool into a powerful, extensible analysis engine. This update brings a suite of intelligent fixers that can automatically modernize your code by leveraging the latest language and library features. Whether you're bumping your Go toolchain version or simply want to keep your codebase clean and idiomatic, go fix is now an essential part of your workflow.

Modernizing Go Codebases with the Enhanced go fix Command — Source: blog.golang.org

Getting Started with go fix

Using go fix is straightforward. Like go build and go vet, it accepts package patterns. To fix all packages beneath the current directory, run:

$ go fix ./...

On success, the command silently updates your source files in place. It intelligently skips generated files, as the correct fix in those cases is to modify the generator itself. We recommend running go fix over your entire project every time you upgrade to a newer Go toolchain release. Since the command may touch hundreds of files, always start from a clean git state—this ensures the change set consists only of go fix edits, making code review a breeze.

Previewing Changes Before Applying

Not ready to commit? Use the -diff flag to see what would change before making any modifications:

$ go fix -diff ./...

This outputs a unified diff of the proposed edits. For example, an old pattern like:

eq := strings.IndexByte(pair, '=')
result[pair[:eq]] = pair[1+eq:]

would be replaced with the cleaner:

before, after, _ := strings.Cut(pair, "=")
result[before] = after

This targeted diff gives you full transparency into what go fix will do, allowing you to review and adjust before finalizing.

Available Fixers and Their Purposes

To see all registered fixers, run:

$ go tool fix help

The current list includes:

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

You can obtain detailed documentation for any particular analyzer by adding its name:

$ go tool fix help forvar

For instance, the forvar analyzer removes unnecessary shadowing of loop variables. Before Go 1.22, it was common practice to redeclare variables inside loop bodies to avoid capturing issues; now go fix eliminates that boilerplate automatically.

Under the Hood: The New Fix Infrastructure

Behind the scenes, the rewritten go fix is built on a modular, analysis‑driven framework. Each fixer is an independent analyzer that inspects the Go AST and, when a pattern is detected, produces a set of precise, safe edits. The tool then applies these edits to the source files, respecting import paths and handling edge cases such as comments and formatting.

This architecture makes it easy for the Go team to ship new fixers with every release. Future versions will automatically run newly added fixers on your existing code, gradually modernizing your codebase without any manual effort.

Empowering Maintainers with Self‑Service Analysis

Perhaps the most exciting aspect of the new go fix is its “self‑service” design. Module maintainers and organizations can now encode their own coding guidelines and best practices as custom fixers. The infrastructure is open and extensible, allowing you to write your own analyses and integrate them with the standard go fix workflow.

This means you can enforce project‑specific conventions—such as naming rules, deprecation warnings, or library‑usage patterns—directly from the command line. By packaging your fixers and sharing them via modules, teams can ensure consistent code quality across large codebases with minimal overhead.

In the coming months, we expect the community to produce a rich ecosystem of custom fixers. The Go Blog will publish detailed tutorials on how to write your own analyzer and plug it into go fix.

Conclusion

The revamped go fix in Go 1.26 is more than a convenience tool—it’s a catalyst for continuous improvement. By automating the adoption of modern idioms and best practices, it helps keep your code clean, efficient, and idiomatic. Run it after every toolchain upgrade, use -diff to stay in control, and explore the rich set of built‑in fixers. And if you need something custom, the new infrastructure invites you to build your own. Start modernizing today with go fix ./....