The go Command

go build compiles a main package and writes the executable into the current directory. go run builds it to a temporary file, runs it, then deletes the binary. go install writes the executable into GOBIN, which defaults to GOPATH/bin.

The go command caches compiled package output keyed by a hash of every input. Unchanged code hashes the same, so the second build reuses the stored result instead of recompiling. Running go env GOCACHE prints the directory that holds it.

A //go:generate line is just a comment; no build step reads it. Only the go generate command scans for these lines and runs each named command in the package directory. go build and go test never run them, so the generated output must be committed.

gofmt reprints a Go file in one canonical layout: tabs for indentation, blanks for alignment, fixed spacing and brace placement, and import specs sorted inside each existing block. It exposes no style settings, so formatting stops being a review topic.

gofmt -l lists the paths of files whose formatting differs, then exits 0 whether that list is empty or not, so the step passes. Make the build fail on non-empty output instead, wrapping it with test -z.

The version suffix makes go install ignore the current module's go.mod entirely. It downloads that module at exactly v1.4.0, builds its command with that module's own dependency requirements, and installs the binary into GOBIN, changing nothing in your project.

The directive must sit immediately above a package-level variable whose type is a string type, a byte slice, or embed.FS, and the file must import the embed package (a blank import when the type is string or []byte). Patterns are relative to the package directory.

A doc comment must sit immediately above the declaration it documents, with no blank line between them. Go has no annotation syntax at all: adjacency is the whole rule, so a single blank line turns documentation into an ordinary comment.

A Go filename ending in a known GOOS or GOARCH value, such as store_linux.go or store_amd64.go, carries an implicit build constraint for that target. The suffix only counts when the value is a real GOOS or GOARCH and something precedes the underscore.

//go:build takes one ordinary boolean expression with &&, ||, ! and parentheses. The older // +build line uses spaces for OR, commas for AND, and repeated lines for AND. When a file has both, //go:build wins.

It makes the term integration true for the whole build, so that file is compiled instead of skipped. Without the flag the file is excluded and anything it declares does not exist. A tag is only present or absent; it carries no value.

The ./... pattern matches every package in the current directory and its subdirectories that belongs to the main module. Building several packages at once only checks that they compile: go build discards the executables and writes no files.

It removes absolute file system paths from the compiled output. Recorded file names become the module path and version, or the package's plain import path, so builds from different checkout directories produce identical bytes instead of embedding /home/alice or /builds/ci.

A package comment is the comment block immediately above a package clause, and it is the first thing a reader sees on the package's documentation page. One file should carry it; a long one usually lives in doc.go.

Generators rewrite their output file whole, so any hand edit is overwritten the next time go generate runs. That is what the DO NOT EDIT header warns about. Put custom code in a separate file in the same package, or change the source the generator reads.

It compares a constant format string against the arguments actually passed: a verb that does not match the argument's type, too few or too many arguments, and formatting directives handed to fmt.Println. The compiler cannot, because Printf takes ...any.

A tool directive records a helper program's package path in go.mod, so its version resolves from the module graph like any dependency. Running go tool with that program's name builds and runs the pinned version, not whatever binary is on PATH.

Ask the go command instead of reading comments: go list -f '{{.GoFiles}}' prints the files in the build and go list -f '{{.IgnoredGoFiles}}' prints those a constraint excluded. Re-run it with the tags and target you expect, then check the constraint, the filename and the placement.

Almost always the script uses @latest, which resolves to whatever the newest release is the moment each machine runs it, and nothing in the repository records what was installed. Pin an exact version per tool, and fix the install destination explicitly.

Compare the build settings recorded in each binary with go version -m, then pin what differs: the toolchain version, GOOS and GOARCH, CGO_ENABLED, the resolved dependency versions, build tags and GOFLAGS. Add -trimpath so the checkout directory stops leaking in.

The -a flag forces every package to be rebuilt from source, including the standard library, instead of reusing cached results. It buys nothing: the build cache is keyed by a hash of all inputs, so anything that changed already causes a rebuild. Drop it and persist the cache.

go doc reads source on your machine, so it shows your working tree as it is now. pkg.go.dev renders a published module version fetched through the public proxy, so it lags your code and never shows a private module.

Because the call copies the struct, and the copy carries its own mutex. Every caller then locks a lock nobody else can see, so mutual exclusion is silently gone. Nothing panics, nothing fails to compile, and the tests still pass.

On a clean checkout, run go generate over the module, stage everything, then run git diff with its exit-code flag. A non-empty diff means the committed generated files are stale, and the printed diff is the fix.

GOFLAGS holds a space-separated list of flags the go command applies by default to any subcommand that knows them, so GOFLAGS=-trimpath makes every build trimmed without editing a single command line. Flags given explicitly on the command line override it.

Go doc comments use a tiny syntax: an empty comment line separates paragraphs, indented lines become a code block or list, hash-space makes a heading, brackets around a name make a link. Other markdown is literal.

go test runs a curated subset of go vet over the package before building anything. A diagnostic there aborts the run, so you see a vet message and no PASS or FAIL lines. The -vet=off flag skips the step.

When a //go:embed pattern names a directory, files and directories whose names begin with a dot or an underscore are skipped from the whole subtree, with no warning. Use the all: prefix on the pattern, and walk the embed.FS with fs.WalkDir to see what is really inside.

Block on checks that are deterministic, fast, and fixable by the author in minutes: formatting, then vet. Keep the regenerate-and-diff check advisory until its version pinning is proven. Every blocking check must run locally with one command.