With the release of Go 1.26, the go fix command has been completely rewritten to help developers automatically modernize their codebases. It identifies opportunities to adopt newer language features, library functions, and best practices, saving time and reducing manual effort. Below, we answer common questions about using go fix effectively.

What is the go fix command and what does it do?

go fix is a tool that analyzes your Go source files and applies a suite of automated transformations, called fixers, to update your code. It detects patterns that can be improved by using more modern parts of the Go language or standard library. For example, it can replace interface{} with any, update loop variable handling for Go 1.22+, or switch from manual map iteration to the maps package. The tool modifies your source files in place (except for generated files) and is designed to make upgrading across Go releases smoother. By running go fix, you ensure your codebase stays aligned with current idiomatic practices without manually hunting for each improvement.

How do I run go fix on my project?

Using go fix is straightforward. Open your terminal, navigate to your project root, and run:

$ go fix ./...

This command processes all packages under the current directory. On success, it silently updates the affected source files. It automatically skips generated files, because the correct fix there is to update the generator logic instead. For a safe experience, start from a clean Git state so you can easily review the changes. The resulting diff will contain only the edits made by go fix, making code reviews much cleaner. If you want to see what would change without actually modifying files, use the -diff flag:

$ go fix -diff ./...

This prints a unified diff to the terminal, letting you preview every transformation before applying it.

What fixers are available and how can I see them?

The current version ships with several built-in fixers, each targeting a specific modernization pattern. To list all available fixers, run:

$ go tool fix help

This displays a table like:

• any – replaces interface{} with any
• buildtag – checks and updates //go:build directives
• fmtappendf – converts []byte(fmt.Sprintf) to fmt.Appendf
• forvar – removes redundant re‑declarations of loop variables (useful for pre‑1.22 code)
• hostport – validates address formats passed to net.Dial
• inline – applies fixes based on //go:fix inline directives
• mapsloop – replaces explicit map iteration with maps package calls
• minmax – rewrites if/else comparisons as calls to min or max

For detailed documentation on any particular fixer, append its name, e.g.:

$ go tool fix help forvar

How does go fix handle generated files?

go fix automatically detects generated files (e.g., those marked with a // Code generated … DO NOT EDIT comment) and skips applying any fixes to them. The reasoning is that generated files are outputs of a generator tool, and any necessary modernization should be applied to the generator itself, not to its output. This avoids repetitive fixes and ensures that when the generator is updated, all future outputs will be clean. If you need to modernize generated code, you should update the source generator and re‑generate the files. The go fix command helps keep your hand‑written code modern while respecting the automated pipeline.

Why should I run go fix after updating to a newer Go toolchain?

Each Go release introduces new language features, library additions, and idioms that older code can benefit from. Running go fix after upgrading your toolchain (e.g., from Go 1.25 to 1.26) ensures your codebase automatically adopts these improvements. For instance, Go 1.22 changed loop variable scoping, and a fixer can remove now‑redundant shadowing. Similarly, new functions like fmt.Appendf or maps.Copy can replace older manual patterns. By making this a regular part of your upgrade process, you keep your code idiomatic, reduce technical debt, and make future maintenance easier. The command can fix hundreds of files in one go, so it’s efficient and reliable when started from a clean repository state.

What is the infrastructure behind go fix and how is it evolving?

The rewritten go fix in Go 1.26 is built on a modular analyzer infrastructure. Each fixer is a small, independent analysis pass that detects a specific pattern and applies a transformation. This design makes it easy to add new fixers without affecting existing ones. The command also supports a “self‑service” model where module maintainers and organizations can encode their own custom guidelines and best practices into fixers. This enables teams to enforce internal coding standards automatically. Looking forward, the Go team plans to expand the set of built‑in fixers and improve the underlying framework to handle more complex rewrites. The goal is to make go fix a central tool for keeping Go code consistently modern across the ecosystem.

Can I create my own custom fixers for go fix?

Yes! The new architecture encourages community and enterprise contributions. You can write your own analyzer that implements the go/analysis interface, package it as a standalone tool, and then run it alongside go fix. The “self‑service” philosophy means that any team can develop fixers that reflect their specific coding conventions, migration patterns, or deprecation policies. For example, a company might write a fixer to replace a deprecated internal library with a new one. Detailed documentation on writing analyzers is available in the Go blog and the go/analysis package documentation. By leveraging this extensibility, organizations can automate large‑scale refactorings that were previously manual and error‑prone.