mrkeyoor.com_
Tue 01 Sept 17:45 UTC
Dev Toolsevaluationupdated 27 Aug 2026

go-modern-guidelines review

Modern Go Guidelines is a version-aware instruction set and small CLI that tells coding agents which Go idioms fit a project's declared Go version. It packages the advice for Junie, Claude Code, Codex, Cursor, and other skill-aware agents, addressing the stale patterns that models often copy from older training examples.

+1,146 / 4dstars / 7d
Verdict

Our run installed 3 packages and passed all 6 tests in 32 seconds total, so trying Modern Go Guidelines is cheap for a Go team that already uses coding agents. Use it as a version-aware reviewer prompt, then check every diff with the compiler, tests, and human judgment. Issue 14's behavior-changing examples and version-detection report make blind acceptance a bad bargain, even with a green suite.

We ran it

Lab card: what happened when we ran go-modern-guidelinesScreenshot of go-modern-guidelines (github.com/JetBrains/go-modern-guidelines)
Install✓ · 16s3 packages
Build✓ · 11s
Tests✓ · 5s6 passed · 0 failed of 6 (go test)
Repo29 files~1,278 lines of source · 0.1 MB · 0 CI workflows

Answers from our run

Does go-modern-guidelines build from source?

Dependencies installed in 16 seconds (3 packages), and the build succeeded in 11 seconds. We cloned commit 40781f1 into a clean Debian container with 3 CPUs and no project-specific setup.

Do go-modern-guidelines's tests pass?

Yes: 6 of 6 passed when we ran the project's own test command (go test). Some failures need services or credentials a bare container does not have.

Who should not use go-modern-guidelines?

Teams that want a deterministic source rewriter: the project gives an agent instructions, while issue 9 asks it to use Go 1.26's go fix before model-led edits.

What are the alternatives to go-modern-guidelines?

Go tools modernize analyzer, Staticcheck, Uber Go Style Guide. Our run installed 3 packages and passed all 6 tests in 32 seconds total, so trying Modern Go Guidelines is cheap for a Go team that already uses coding agents.

Setup5/53 packages installed; build and all 6 tests passed
Docs4/5Agent-specific install and update paths are documented
Community3/51,863 stars and active defect discussion, but only 6 items open
Maturity3/5Small tested CLI, no tagged release, semantic fixes still open

Who it’s for

Go teams that already use coding agents and want generated changes to respect the module's Go version.
Reviewers who want an agent to explain why it chose a newer standard-library helper.
Claude Code, Codex, Cursor, and Junie users willing to install a third-party plugin or skill.
Maintainers who will still run their own tests and inspect semantic changes before merging agent output.

Who it’s NOT for

Teams that want a deterministic source rewriter: the project gives an agent instructions, while issue 9 asks it to use Go 1.26's go fix before model-led edits.
Developers who assume every suggested rewrite preserves behavior: issue 14 documents six examples that changed results for cases involving absent separators, cancellation, nil maps, NaN values, and empty slices.
Projects without a Go toolchain on PATH: the README says the marketplace wrapper installs its CLI with go install and targets Go 1.25 or newer.
Users who require tagged releases and fixed-version upgrade notes: GitHub returned no latest release for this repository.
Teams that cannot review third-party agent instructions: a reported version-detection defect can recommend code that does not compile for a module whose go.mod lacks a go directive.

Setup reality

Our sandbox installed 3 Go packages in 16 seconds, built the checkout in 11 seconds, and passed all 6 tests in 5 seconds. The commit had 29 files, about 1,278 source lines, and occupied 0.1 MB before installation.

The agent integrations need a Go toolchain on PATH; they do not require service credentials. First use runs go install into a local cache. Go older than 1.25 needs automatic toolchain switching enabled so it can fetch a compatible toolchain.

Each supported agent has a different marketplace command and update path. The repository had no CI workflow, Dockerfile, or tests directory in our scan, although go test still found and passed 6 tests in package files.

The CLI selects advice from the module's Go version

Modern Go Guidelines gives coding agents a table of language and standard-library features, filtered by the version a project can compile. The examples range from slices.Contains to Go 1.26 additions such as errors.AsType[T]. Its wrapper asks the CLI for a list before an agent edits a Go file, and the agent can request an explanation for a specific rule. That is a narrower job than formatting, linting, or rewriting an existing codebase.

The repository distributes the same core skill through Junie, Claude Code, Codex, Cursor, and skills.sh. Each marketplace has its own install and refresh commands. The wrapper puts its CLI in a local cache and does not modify the target repository during installation. A Go toolchain must be available on PATH, and the CLI targets Go 1.25 or later. Older installations rely on GOTOOLCHAIN=auto to obtain a compatible compiler on first use.

Version filtering is useful, but one reported path chooses the wrong version

The best part is the file-aware lookup. Given a Go source path, the tool reads the surrounding module information and returns only advice allowed by that version. This matters because an agent that suggests min to a Go 1.20 module has produced code the module cannot compile. The skill also tells the agent to read the full list and to request details before skipping a relevant rule.

Issue 14 reports two holes in that promise. A go.mod without a go directive is treated like the local toolchain, although the Go command assigns that module language version 1.16. The report shows the CLI recommending new(30), which then fails because the module language is too old. It also says bare list does not inspect the current directory's go.mod; passing --file-path does. The documented workflow prefers a file path, but the first case can still produce broken code.

What happened when we ran it

Our sandbox installed 3 packages in 16 seconds, built the project in 11 seconds, and passed 6 of 6 tests in 5 seconds. We used commit 40781f1 in an unprivileged Debian container with 3 CPUs, 8 GB of RAM, no secrets, and the golang:1.24-bookworm image. Nothing in the install, build, or test logs failed.

The checkout was only 0.1 MB, with 29 files and about 1,278 lines of source. Our scan found no GitHub Actions workflow, Dockerfile, or tests directory. The lack of a tests directory does not mean there were no tests: go test discovered 6 tests in the package layout and all passed. The missing CI files mean the repository does not show an in-repo automation path for repeating that result on proposed changes.

Six passing tests do not cover the disputed examples

A green local run is reassuring for the CLI mechanics, but open issue 14 is directly relevant to what the tool teaches. It documents six before-and-after examples whose results differ in specific cases. One swaps outputs when strings.CutLast sees no separator. Another removes a context cleanup by deferring the stop function. Others change nil-map write behavior, NaN handling, or the distinction between nil and an empty slice.

Pull request 20 proposes fixes for those 6 examples, while the issue says its wrong since_version and Go-version detection parts remain outside that change. Pull request 13 separately corrects a new example and adds behavior caveats to summaries that agents see. These are not abstract style disagreements. They show why agent instructions need the same review standard as source code: a concise modernization can compile and still change a program's result.

This complements analyzers instead of replacing them

The tool helps most while an agent is writing new code. For an existing package, deterministic analyzers deserve the first pass because their findings can be repeated without asking a model to interpret prose. Issue 9 makes this point for the modern go fix flow introduced with Go 1.26, asking the skill to run it before model-led modernization. That proposal is still an issue, not documented behavior in the current README.

A sensible workflow uses the guidelines to reduce stale code at generation time, then runs gofmt, analyzers, the compiler, and project tests. The instruction set cannot know whether a zero value is meaningful to your business logic or whether a nil slice must remain nil for JSON output. The project's own disputed examples make those boundaries unusually concrete.

August defect activity is healthier than the missing release history

GitHub showed 1,863 stars, 6 open issues and pull requests combined, and a last push on August 19, 2026. Several defect reports and proposed fixes were active on August 26. That is current issue activity even though the repository API returned no latest release. A missing release tag limits fixed-version adoption and change notes; it does not by itself make the project abandoned.

Modern Go Guidelines is worth installing for a team that already reviews agent output and wants fewer stale idioms. Our 32 seconds of install, build, and test time makes evaluation easy. Keep its authority bounded: let it suggest version-appropriate syntax, but require normal Go checks and a semantic review before accepting the result.

Alternatives

ProjectWhat it isPick it when
Go tools modernize analyzerThe Go project's analyzers can find mechanical modernizations in existing code.pick this instead when you want diagnostics from a Go tool rather than instructions interpreted by an agent.
StaticcheckA mature static-analysis suite for correctness, simplification, and style checks in Go.pick this instead when repeatable analyzer findings matter more than coaching generated code.
Uber Go Style GuideA human-readable guide to consistent and idiomatic Go across a team.pick this instead when people need a broad house style rather than version-gated agent instructions.

What people are saying

  1. [github-trending] JetBrains/go-modern-guidelines

Sources

  1. Modern Go Guidelines README
  2. GitHub repository facts
  3. Issue 14: eight reported defects
  4. Pull request 20: behavior-preserving example fixes
  5. Issue 9: proposed go fix workflow

More dev tools reviews

workmux · v2rayNG · SecLists · hashcat · eslint · fastfetch · the whole board →