JetBrains go-modern-guidelines: Teaching AI Coding Agents to Write Modern Go

The Problem: AI Agents Generate Outdated Go Code

The README identifies two root causes for why AI coding agents consistently produce older Go patterns. The first is training data lag: models trained before a certain cutoff have no exposure to features added after that date, so they cannot use constructs like `errors.AsType[T]` from Go 1.26 if none appeared in the training corpus. The second is frequency bias: even for features the model knows, older patterns appear far more often in training data. A model has seen far more `for i := 0; i < n; i++` loops than `for i := range n` range-over-integer loops, so it reproduces the older form by default.

The guidelines give the agent an explicit reference that overrides both problems. When an agent processes a Go task, it checks these guidelines and uses the modern idiom instead of the statistically probable older one.

What the Guidelines Actually Cover

The guidelines cover features from Go 1.0 through Go 1.27, including everything targeted by Go's own `modernize` analyzer. The README gives concrete examples of the substitutions an agent makes when the guidelines are active:

- `max(a, b)` instead of an if-else comparison block. - `slices.Contains` instead of a manual loop. - `cmp.Or(a, b, c)` instead of a chain of nil checks. - `new(42)` to get a pointer to a value (Go 1.26). - `errors.AsType[T](err)` for type-safe error matching (Go 1.26).

The complete list with descriptions and code examples lives in `FEATURES.md` in the repository. The agent reads the project's `go.mod` to determine the declared Go version and applies only the features available up to and including that version. A project declaring `go 1.21` does not receive Go 1.26 patterns.

The connection to the `modernize` analyzer is explicit in the README: the Go team's `modernize` analyzer exists to update existing code to current idioms; these guidelines serve the same goal for new code generated by agents.

Installing the Skill in Claude Code

The installation requires two commands inside a Claude Code session:

/plugin marketplace add JetBrains/go-modern-guidelines

Then install the plugin:

/plugin install modern-go-guidelines@goland-claude-marketplace

Once installed, Claude Code invokes the skill automatically when relevant to a Go task. To trigger it explicitly, use:

/modern-go-guidelines:use-modern-go

Automatic updates are disabled by default for third-party marketplaces. To enable them, open `/plugin`, navigate to Marketplaces, select `goland-claude-marketplace`, and enable auto-update. After Claude Code reports a plugin update, apply it to the current session with:

/reload-plugins

To update manually, use:

claude plugin marketplace update goland-claude-marketplace
claude plugin update modern-go-guidelines@goland-claude-marketplace

Installing in Junie, Codex, Cursor, and Other Agents

The skill package is distributed for multiple agents. In Junie CLI, add the marketplace and install the extension:

/extensions marketplace add JetBrains/go-modern-guidelines
/extensions install modern-go-guidelines

In Codex, the commands use `codex plugin`:

codex plugin marketplace add JetBrains/go-modern-guidelines
codex plugin add modern-go-guidelines@goland-codex-marketplace

For Cursor, add the marketplace via terminal then use the in-session `/plugins` command to install. Cursor does not currently provide a non-interactive CLI command for updating installed plugins, so reinstalling through `/plugins` is the documented update path.

For other agents that support the skills.sh protocol, including OpenCode:

npx skills add JetBrains/go-modern-guidelines

To install only the use-modern-go skill without the rest of the package, add `--skill use-modern-go` to the npx command.

Runtime Requirements and the CLI Component

The marketplace integrations do not bundle a static guidelines file. Instead, they run a small CLI that is installed on first use with `go install`. The Go toolchain must be installed and available on PATH before the first invocation. The README states that the CLI targets Go 1.25 or newer; on older Go versions, automatic toolchain switching (`GOTOOLCHAIN=auto`, the default Go behavior) allows Go to fetch a compatible toolchain on first run.

The CLI is cached in a local directory: `$XDG_CACHE_HOME/go-modern-guidelines` or `~/.cache/go-modern-guidelines` on systems without `$XDG_CACHE_HOME` set. It never modifies the project directory. Developers who want to test local changes to the CLI set `GO_MODERN_GUIDELINES_DEV=1` in the environment before launching the agent:

export GO_MODERN_GUIDELINES_DEV=1

With this variable set, the agent runs the local build from the cache directory instead of the released version. Running `make dev-install` after edits rebuilds the local binary.

Limitations and What the Guidelines Do Not Fix

The guidelines address generation of new code, not detection of bugs or security issues. An agent using these guidelines writes modern Go idioms from the start, but the guidelines do not substitute for code review, static analysis, or testing.

The skill applies only when the agent identifies the task as Go-related. Mixed-language repositories or tasks where the agent does not recognize the Go context may not trigger the guidelines automatically. The explicit invocation command (`/modern-go-guidelines:use-modern-go` in Claude Code) is the fallback for those cases.

Version gating depends on the project having a valid `go.mod` file with a `go` directive. Repositories without a `go.mod` or with a malformed directive may not receive accurate version-specific guidance; the README does not document the fallback behavior for this case.

go-modern-guidelines Versus Manual go vet and golangci-lint

The alternative to a skill like this is running the `modernize` analyzer after code generation, either as a standalone tool or through golangci-lint. The `modernize` analyzer, mentioned in the README and demonstrated in a Go team talk, finds outdated patterns in existing code and suggests corrections.

The difference in approach is timing. `modernize` is a post-generation linter: it flags old patterns after the agent has written them, requiring a separate review and fix cycle. go-modern-guidelines is a pre-generation reference: the agent reads the guidelines before writing and produces modern patterns in the first pass. For teams running AI-assisted development at volume, avoiding the fix cycle is the practical advantage.

The two approaches are complementary. The README positions these guidelines as the generation-time counterpart to what `modernize` does for existing code.

Editorial conclusion

go-modern-guidelines is the right tool for teams whose AI coding agents produce outdated Go patterns such as manual loops in place of slices.Contains or verbose nil-check chains instead of cmp.Or. The skill installs in minutes and functions automatically when the agent detects a Go task. Before adopting it, confirm that the Go toolchain is installed and accessible on PATH, since the CLI component is fetched and installed on first use. The project targets Go 1.25 or newer; on older Go versions it depends on GOTOOLCHAIN=auto to fetch a compatible toolchain automatically. The last push was on 2026-09-10.

Frequently asked questions

Official sources

1. Issues
2. JetBrains/go-modern-guidelines on GitHub
3. License: Apache-2.0
4. README