Will Go And AI Ever Fit Together?

Hi ,

The Go team got productive! Well, they are always productive, but in this particular case I mean the frequency of pushing new blog articles. Two new articles came out within three days (14th and 16th of October)! And both bring good news: gopls supports interactive refactoring (a feature that IDEs had to implement themselves previously), and HTTP/1 reused connections more efficiently in Go 1.27.

Plus swiss tables, an expressive Go frontend, Python vs. Go, escape analysis, and me thinking loud about AI (again).

(All em-dashes in my comments proudly handcrafted.)

Happy coding!

–Christoph

Featured articles

Interactive refactoring in gopls

Refactoring usually is an IDE feature. Now the Go language server gopls implements a number of refactorings, available in gopls v0.24.0 and vscode-go v0.56.0, and maybe also in Neovim and Emacs soon (proofs of concept exist).

Better HTTP/1 connection reuse

What do you do if your HTTP/1 connections are slow? Switch to HTTP/2, haha!

YEAH BUT that's not always an option. If your app or lib has to support HTTP/1, try Go 1.27.x and enjoy a decent speedup for repeated requests.

[security] Go 1.27.2 and Go 1.26.9 are released

Make your apps and libraries safer at virtually no extra cost! Simply bump your projects to the latest Go versions, 1.27.2 and 1.26.9 now and thank me later.

Podcast corner

How many engineers does it take to deprecate a struct?

Just one day after the live SF session, a new episode is out, with breaking news (most prominently, the new Go releases with critical security fixes).

A profile of profile proposals, and Daniela Petruzalek talks about devrel, podcasts, and building agents with Go

What's a DevRel role? Do devs have relationships, after all? Daniela Petruzalek met Jonathan and Shay to discuss what Developer Relations means, a new Go podcast she might be starting, her work on AI agents for Go, and Ebitengine (the game engine library).

Spotlight: Writing Go in the Age of AI

A fair amount of my recent Spotlights contains AI-related content, and I know that some of you wonder whether I'm slowly drifting into the vibe-coding camp. While self-assessment is highly subjective and prone to unconscious biases, I'm pretty sure that I haven't completely fallen for the AI hype.

Sure, AI, and particularly the Large Language Model (LLM) division made astonishing achievements within the last years, with the biggest jumps in actual usefulness having happened within months only. But I do see the downsides of this technology as well. The boom of LLMs has a significant impact on society, both through the training and the inference phase, albeit in different ways.

This boom seems to cause many people to take extreme stances: Some celebrate AI as the universal solution for many of the world's problems, while others condemn AI as a technology from hell, a new super-drug that's going to drag us all in, make us dumb and completely depending on a few right-wing tech oligarchs.

Usually (and I'm sure this applies to AI, too), reality lies somewhere in the middle. However, "somewhere in the middle" is a lazy take, especially for us Gophers who are directly affected by the new technology. Having written code by hand for years, we have the right to stay skeptical about the changes that LLMs bring to software development. A healthy dose of skepticism is not the same as Luddism; it's a healthy engineering instinct. After all, software engineering has an inherent distrust of systems that have no clear, reproducible behavior.

I don't see skepticism as a mood (let alone an excuse for being against everything); for me, it's a viable method for seeking the truth behind the claims.

So I decided to start an article series about how to embrace the good parts of AI for Go projects while staying critical to its downsides.

What this series is about

When a problem seems hard to tackle, it's often because there are several aspects to it that muddle our view on that problem. Once you look beneath the surface, you start seeing multiple facets, angles, and viewpoints. You begin meandering from "what if" to "but also", bounce between "this is rad" and "WTF", and finally you find yourself entangled in an unruly mess of arguments that seem to never agree.

To cut through the mess, I will first diagnose the problem and then inspect it from several distinct perspectives. I will try to find answers, and, for aspects where are none, ways to come to terms with them.

Full disclosure: I do talk to the clankers about this series; not one, but five of them (at the moment). They help with research, challenging my thoughts, copyediting, and other supportive tasks; I never let them write any part of my texts; these are still mine.

Let's continue to write Go in the age of AI, without losing our craft, judgement, or conscience.

Quote of the Week: Mid-Wow

At scale you are always mid-migration, mid-rewrite, mid-wowthiscodeisbad.

– Swizec Teller

More articles, videos, talks

How Go Maps Work Internally: Swiss Tables - YouTube

Without taking breath, Phong Le dissects the internals of Go maps, with animated diagrams following his explanations. Woosh, Today You Learned: Swiss Tables.

XGo and LLGo: a more expressive Go front end and an LLVM-based compiler for the C ecosystem

Go intentionally leans toward the verbose side of things. Readability trumps saving a few keystrokes. But some see the verbosity as an obstacle to readability. The author of XGo dreamed of (and realized) a Go "frontend" that features a much more concise syntax, for the better or worse. Their second project is LLGo, a Go compiler based on LLVM, for better interaction with the C world.

Python vs Go: A Practical Comparison for Developers

Are Go and Python even comparable? They surely have more differences than similarities, but that's not an excuse for not taking a look at both side by side.

nobloat/poll - designing a minimal poll tool

Why would someone want to write another poll app? Because (a) there are few self-hostable ones strong, and (2) it's fun to write!

Escape Analysis in Go: Stack or Heap? - YouTube

Function-local variables can be created on the stack (which is cheaper than the heap), as they are no longer needed when the function ends. But there are several scenarios where local variables outlive the function they're defined in. Garbage-collected languages like Go manage these scenarios through escape analysis. While developers usually don't get in touch with escape analysis (or even have to think about it), understanding the concept and how it affects memory allocation helps to reduce work for the garbage collector.

Panel with the Go Team | GopherCon EU 2026 - YouTube

Roland Shoemaker and Jonathan Amsterdam talk to Bill Kennedy about how AI-discovered vulnerabilities lead to investments in automated triage, using AI assistants for test and coding while maintaining human oversight, the rationale behind new standard library data structures, why immutable types would complicate the language, and other topics.

"We don't want to become a Rust or a C++. Not that there's anything wrong with those languages, they are very very powerful. But they're just not where we want to live."

"Everyone at the pottery class painted flowers. I painted a gopher :)"

Projects

Tools and applications

fclairamb/solidping: Distributed, self-hostable uptime monitoring: 40 check types, multi-region workers, private agents, status pages, incidents and on-call escalation — in a single Go binary.

A nightmare for companies and self-hosters: A service goes down and no one notices—except for your customers! SolidPing ensures you stay informed about your service landscape. Available as a hosted service or as a lightweight docker container (a single Go binary with SQLite underneath).

oxynote/oxynote: Your system, with subtitles. Notion-style pages with live observability charts, Stripe-style API docs and pull-request-style reviews

What do Grafana and Notion have in common? Not much, and that was exactly what the authors of Oxynote wanted to change. The result is a unified dashboard experience where live data lives next to relevant explanations, flow diagrams, support notes, and whatever information is needed to finally turn colorful graphs into meaningful, breathing documents. (Hence "Oxynote"—named after that breathable stuff called oxygen.)

Undocumented graphs and out-of-date docs will be a thing of the past.

belluikit/bellui: Cross-platform Go UI toolkit with Material Design 3 widgets and WebGPU rendering, for desktop, mobile and the web. Forked from Fyne.

Many Go UI toolkits are HTML DOM based; Fyne has been desktop first from the beginning. Bellui is a fork of Fyne that uses WebGPU rendering with a fallback to OpenGL.

Completely unrelated to Go

AI is driving a boom in modestly successful software projects

Where's the big AI revolution ? Why don't we see vastly successful, vibe-coded enterprise applications? Because today's AI coding agents are mostly used to solve niche problems.