Go 1.26 Revolutionizes Code Maintenance with Fully Rewritten 'go fix' Command

The Go team has unveiled a completely rewritten go fix subcommand in the just-released version 1.26, promising to automate the modernization of Go codebases at an unprecedented scale. The overhauled tool uses a suite of analysis algorithms to detect and automatically apply improvements, leveraging the latest language and library features.

“Go fix uses a suite of algorithms to identify opportunities to improve your code, often by taking advantage of more modern features of the language and library,” said Alan Donovan, Go team member.

Developers can run go fix ./... to fix all packages under the current directory. The command silently updates source files on success, skipping any changes that touch generated files. Donovan recommends running the tool with each upgrade to a newer Go toolchain release to keep codebases current.

How to Use the New go fix

To preview changes before applying them, use the -diff flag: go fix -diff ./... This shows a unified diff of the proposed edits, making code review straightforward.

The full list of available fixers, known as analyzers, can be displayed with go tool fix help. Each analyzer targets a specific pattern, such as replacing interface{} with any, converting []byte(fmt.Sprintf) to fmt.Appendf, or replacing if/else blocks with min and max calls.

Background: Evolution of Go Tooling

The original go fix command, introduced years ago, provided basic automatic refactoring for major language changes. The 1.26 rewrite represents a fundamental architectural shift, moving from a fixed set of rules to an extensible analysis framework. The new infrastructure is designed to evolve with the Go ecosystem.

Donovan explained that the rewrite is part of a larger initiative to create a “self-service” analysis platform. This will allow module maintainers and organizations to encode their own guidelines and best practices into reusable analyzers, potentially unifying internal code standards across projects.

What This Means for Go Developers

For individual developers, the new go fix drastically reduces the manual effort needed to adopt modern Go idioms. For teams, it ensures consistent code quality and style across the entire codebase. The ability to run all fixers in one pass—and the safety net of the -diff flag—makes it practical to integrate into CI/CD pipelines.

Organizations can now craft custom analyzers to enforce company-wide rules, reducing code review friction and accelerating onboarding. “We recommend running go fix over your project each time you update your build to a newer Go toolchain release,” Donovan emphasized. Starting from a clean git state ensures that changes are clearly attributable to the tool, simplifying review.

The release also includes a set of built-in analyzers covering common pitfalls, such as redundant loop variable declarations, outdated build tags, and inefficient map iterations. As the Go project continues to refine its static analysis capabilities, the line between go vet (for bug detection) and go fix (for code improvement) will likely blur.

Complete List of Built-in Analyzers

• 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 format of addresses passed to net.Dial
• inline – applies fixes based on //go:fix inline comment directives
• mapsloop – replaces explicit loops over maps with calls to maps package
• minmax – replaces if/else statements with calls to min or max

To see detailed documentation for any analyzer, use go tool fix help <analyzer-name>. For instance, go tool fix help forvar explains that the fixer removes unnecessary shadowing of loop variables, a common pattern before Go 1.22 introduced loop variable semantics changes.

While the command is designed to be safe, Donovan advises caution: “It discards any fix that touches generated files since the appropriate fix in that case is to the logic of the generator itself.” This ensures the tool doesn’t perpetuate errors in code generation pipelines.

Looking Ahead

The rewritten go fix marks a turning point in Go’s tooling strategy, shifting from reactive fixes for language version changes to proactive modernization. As the ecosystem embraces this self-service model, teams can expect fewer legacy patterns and more idiomatic Go code across the board. The Go team encourages developers to experiment with custom analyzers and share feedback for future improvements.