Boost Your Go 1.24 Workflow: New go tool Command & Vet Enhancements Explained

Go 1.24 introduced important updates to the Go tool ecosystem, focusing on the go tool command and the vet static analysis tool.

Go command enhancements

In Go 1.24 the go command adds a tool directive in go.mod, allowing developers to track executable tool dependencies directly without using indirect solutions such as empty imports.

Using the tool directive to track executable tool dependencies

For projects that rely heavily on tools like mockery, the new directive simplifies version management. Previously, developers created a tools.go file and used empty imports to declare tools. With Go 1.24 you can declare them directly in go.mod:

# Install mockery with the new tool directive
gotip get -tool github.com/vektra/mockery/[email protected]

This command adds a tool entry to go.mod:

module huizhou92.com/tools

go 1.24

tool github.com/vektra/mockery/v2

require (
    github.com/vektra/mockery/v2 v2.52.1 // indirect
)

Afterward you can install a specific version with gotip install tool or run the tool directly:

gotip tool github.com/vektra/mockery/v2 --all --output ./mocks

My local mockery version is 2.32.3.

This approach eliminates the need to manage separate installation steps or maintain dedicated files.

Caching executable files to speed up runs #69290

Another improvement is that executables produced by go run or go tool are now cached in Go's build cache (previously only compiled packages were cached). This speeds up repeated executions, though it increases cache usage.

Go automatically cleans compiled package caches after five days; executable caches may be cleaned after two days.

If you frequently use custom tools or scripts during development, this caching can save valuable time.

Vet tool enhancements

The static analysis tool vet adds new analyzers and improves diagnostics in Go 1.24, helping developers catch potential bugs earlier.

New Tests analyzer

The Tests analyzer detects problems in test declarations, such as incorrect naming, wrong function signatures, or references to undefined identifiers.

// Incorrect test function signature (missing *testing.T parameter)
func TestMyFunction() {
    fmt.Println("This test will not run")
}

Running go vet ./... yields:

blog-example/go1.24/tools/demo_test.go:5:1: wrong signature for TestMyFunction, must be: func TestMyFunction(t *testing.T)

Catching such errors ensures tests run correctly and prevents unexpected CI/CD failures.

Improved Printf analyzer

The Printf analyzer now flags non‑constant format strings passed without matching arguments, which can cause runtime errors.

s := "Hello %s"
fmt.Printf(s) // If s contains a placeholder, this will cause a runtime issue.

In Go 1.23 this passes silently, but Go 1.24 vet reports:

non-constant format string in call to fmt.Printf

Fix the issue by using fmt.Print(s) when no formatting arguments are needed.

Conclusion

Go 1.24 also updates several other tools, including:

Go build supports generating pseudo‑versions (#50603)

Default enable GOCACHEPROG to support external caches (#64876)

Go toolchain supports HTTP authentication (GOAUTH) (#26232)

Go build supports -json output (#62067)

…

These seemingly small but practical changes can greatly boost developer productivity and code reliability. By tracking executable tool dependencies with the tool directive and leveraging the enhanced vet diagnostics, you can write higher‑quality Go code and avoid downstream issues.