Anton Zhiyanov published Go Concurrency Distilled, a free interactive mini-book covering 17 Go concurrency topics, from goroutines and channels up through atomics and diagnostics. Every example runs in the browser, so you can change the code and rerun it without installing anything. A static PDF version lives in the nalgeon/go-conc-distilled repository if you prefer reading offline.
Zhiyanov is explicit about who this is for: it is a refresher, not a beginner’s guide. If you already know Go and want to sharpen the concurrency mental model, this is the target reader. People learning from scratch are pointed at his longer companion book, Gist of Go: Concurrency, which has auto-tested exercises. The two-book split is sensible. One book for learning, one for recalling, and conflating the two is how most programming tutorials end up serving neither audience well.
What it covers
The topic list reads like a checklist of everything you touch when concurrent Go code misbehaves: goroutines, channels, select, pipelines, time operations, context cancellation, wait groups, data races, race conditions, mutexes, semaphores, signaling, sync.Once, object pools, atomics, testing, scheduling, and diagnostics. That last group is the part most guides skip. Runtime metrics, profiling, and tracing get their own coverage, which matters because concurrency bugs in production rarely announce themselves in code review.
The gotchas section is worth the price of admission on its own, and the price is zero. A channel can only be closed once. Writing to a closed channel panics. Closing a nil channel panics. Reading or writing a nil channel blocks forever. Every Go developer has met at least one of these in production, usually at an inconvenient hour, and the guide states them plainly instead of burying them in prose about communication philosophies.
Patterns that actually hold up
Beyond primitives, the book collects the standard working patterns: output channels, done channels, cancel channels, pipeline error handling with first-error returns and separate error collection, and using select for non-blocking sends. These are the shapes you see in real codebases, not textbook curiosities. The coverage sticks to the standard library sync toolbox throughout, which is a defensible choice even though many production guides treat golang.org/x/sync/errgroup as the default for error-propagating goroutine groups. The book covers context cancellation but leaves errgroup out, so if your team leans on errgroup for fan-out and fan-in, that part stays external.
One timing detail worth noting: the examples use WaitGroup.Go, added in Go 1.25. That method removes an entire class of Add/Done mismatch bugs by scoping the counter bookkeeping with the goroutine itself. If your team has ever chased a panic from a WaitGroup reused too early, the newer API is the fix, and the book teaching it from the start is the right call.
The AI-free label
The author labels the book AI-free, and in 2026 that is a real differentiator rather than a vanity tag. Tutorial content is drowning in machine-generated rewrites of the same five explanations, each stripped of the author’s opinions and failure stories. Zhiyanov’s material has earned its examples the slow way, and the interactive format reinforces that: a static list of code snippets you cannot run invites skimming, while runnable examples invite breaking things, which is where the learning happens.
It also raises a fair question about how we evaluate learning resources now. An interactive book with runnable examples has a built-in quality check, since broken code breaks in front of you. A wall of generated prose has no equivalent. When you pick your next reference, favor the ones where someone demonstrably ran the code.
How to read it
The book rewards a specific reading strategy. Do not go top to bottom in one sitting; the value compounds when you run every example and deliberately break it. Send on a closed channel to see the panic. Open a nil channel and watch the read block. The interactive format exists so you can cause these failures in a browser tab instead of in production, and the difference between reading about a deadlock and watching one hang a snippet you just typed is the whole point of the format.
If your team does code review on Go services, the channels and pipelines chapters double as a shared vocabulary. Half the arguments about who should close a given channel dissolve once everyone has run the same examples and seen the same panics. That is a cheaper investment than the incident that eventually forces the conversation anyway.
Who should read it
If you write Go and your concurrency knowledge was assembled from blog posts and debugging sessions rather than a systematic pass, this fills the gaps in an afternoon. Skim the topics you know, slow down on diagnostics and the nil-channel traps, and run the examples rather than reading them. The companion Gist of Go book remains the better starting point for developers new to Go concurrency. For everyone else, Distilled does exactly what its name promises: the essentials, without the filler.