Build1 distinct publisher2 min readPublished
The tell in a 1,039-line refactor was not a missing feature but a hand-rolled substring scan with a comment defending it. go-modern-guidelines gates its advice on your go.mod.
The Engineer · Build desk
Compiled by The EngineerSomething wrong?How this is made
The hand-rolled loop is the more interesting of the two failure modes, because it is not ignorance. The magic number 13 in that scan is exactly the character count of "invalid_grant" [1], so whatever wrote it measured the needle and then built a bounds-checked walk over the string rather than call a function that has shipped in the standard library for the language's entire public life. It also left a comment justifying the choice [4]. That is frequency bias at its most expensive: not an absent feature, but a plausible rationale for avoiding one, which survives review because reviewers read comments as decisions rather than as output. The replacement was a single call to strings.Contains [5].
The design decision here worth copying is the version gate. `list` resolves the applicable rule set from go.mod, go.work, or the local toolchain [7], and the write-up's stated reason is blunt: without it an agent will cheerfully propose errors.AsType[T] and break a build running Go 1.24 [9]. Most house style guides fail in the other direction, describing a language version nobody's CI is on. This one refuses to describe features your own module cannot compile.
The content is thinner than the framing suggests, and the diff between two adjacent versions shows why. Moving from 1.21 to 1.22 adds five entries [10], roughly an eighth of what a 1.24 project sees [2], and most of them are one-for-one substitutions: a new stdlib call in place of an old one, a loop form in place of a copy. That is a changelog with opinions attached, which is a reasonable thing to hand a model, but it is not architecture advice.
Where `explain` earns its place is the caveat text. For cmp_or, the details note that all arguments are evaluated before the call [11], which is precisely the regression a mechanical rewrite introduces when the fallback branch is an expensive lookup. An agent given only the one-line summary makes that substitution everywhere. An agent given the explanation has a reason to decline it in one place out of ten, and knowing when a rule does not apply is the part of a style guide that usually goes unwritten.
Two limits are worth stating plainly. This is one developer's test of one file in their own project, a 1,039-line main.go [12], not a measured before-and-after across a codebase. And the tool is a CLI with two subcommands that print text when asked [6]; nothing described makes it fire during generation. The knowledge gap is now addressable. The habit of consulting it is still yours to enforce.
Ranked by verification strength, evidence, and original report placement.
JetBrains released go-modern-guidelines, a project positioned to provide contemporary Go writing specifications for AI agents so they do not write outdated Go due to knowledge cutoffs.
The first layer of the problem is the training data cutoff: anything added to the standard library after the cutoff will not be used because the model has not seen it. The project's own example is errors.AsType[T], added in Go 1.26.
The project calls the second layer frequency bias: even when a model knows the new form, the old form appears overwhelmingly more often in training data. In ten years of Go on the internet, interface{} appears far more than any, and sort.Slice far more than slices.SortFunc, so probabilistic prediction usually picks the old one.
The refactored project contained a hand-rolled substring search that looped over err.Error() comparing 13-character slices against "invalid_grant", with a comment stating it was a basic substring check to avoid importing "strings".
The author states the code only needed one line: strings.Contains(err.Error(), "invalid_grant"), and that the cost of importing the standard library strings package is zero.
The tool is a CLI with two subcommands: list, which returns the guidelines supported by a Go version sorted newest to oldest, and explain, which returns detailed explanations and before/after examples for specific guideline IDs.
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Reproducible command output, one observer
The mechanics are unusually checkable for a single-source story: actual list and explain output, a version diff naming five guidelines, and the offending code snippet are all reproduced verbatim, so the tool's behaviour is well evidenced. What is not evidenced is any outcome measurement or second observer, which caps the score in the middle band.
One disclosed trial plus plugin availability
Adoption evidence is limited to the release itself, availability as a Claude Code plugin, and a single self-reported refactor of one file by the article's author. No install counts, organizational deployments, or third-party usage are supplied.
Mildly overstated benefit, solid mechanics
The framing that the plugin 'makes your AI Agent smarter' outruns what is shown, since no before/after quality measurement or repeat trial is reported and the corpus is one anecdote. The gap stays small because the specific mechanical claims are demonstrated rather than asserted, and the article volunteers a genuine caveat (cmp.Or evaluating all arguments) rather than only upside.
Vendor tool, enthusiastic third-party write-up
The subject is a vendor artifact from JetBrains and the write-up ends with copy-paste install instructions and promotional language, so some alignment with the vendor's interest is visible. Offsetting this, the author is an independent practitioner on a community platform reporting their own project and disclosing a pitfall and a rule they violated; no sponsorship or affiliation is stated in the supplied material.
Mechanics reliable, impact unverified
Confidence in what the tool does is high because command output is quoted; confidence in whether it changes agent output quality at scale is low because the cluster holds one publisher, one author, and one project. Licensing, maintenance cadence, and comparison to existing Go modernizers are entirely absent.
build
2,513 tool calls, zero refactorings: what agents actually do when you ask them to refactor1 distinct publisher
build
The compiler checks three of the seven things your coding agent had to get right1 distinct publisher
product
Four leaderboards, four denominators: what you buy when you standardize on a coding agent1 distinct publisher
build
Copilot is now the minority tool, and your 2025 standardization decision knows it1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 26, 2026