This is a mini-book that knows exactly what it is and refuses to be anything else. Anton Zhiyanov's 'Go Concurrency Distilled' covers 18 concurrency topics — goroutines, channels, select, pipelines, mutexes, atomics, semaphores, and more — with interactive code examples you can modify and run in-browser. It's a reference shelf, not a classroom. The structural bet here is compression. Each topic gets a single-screen treatment: a code block, a one-paragraph explanation, and maybe a follow-up pattern. Channels get coverage of directional types, buffering, nil behavior, and iteration — all in roughly the space a typical blog post would spend on just buffered channels. The density is the feature. What works is the layering. Zhiyanov starts with goroutines and WaitGroups, moves to channels and select, builds to pipelines and cancellation patterns, then shifts into shared-state territory with mutexes, atomics, and semaphores. The ordering mirrors how most Go developers actually encounter concurrency: message-passing first, shared memory when you must. Each section implicitly argues for the Go way of doing things without belaboring the philosophy. The interactive examples are the real differentiator over a static cheat sheet. Being able to change a buffer size from 3 to 0 and watch the deadlock happen teaches more than three paragraphs of explanation. The code is clean, minimal, and idiomatic — no enterprise boilerplate, no unnecessary abstractions. The 'AI-free' label is a quiet statement of craft accountability. The limitation is baked into the premise. If you don't already understand why a nil channel blocks forever or what a race condition looks like in production, the explanations here won't get you there. Zhiyanov explicitly says this is a refresher, not a beginner's guide, and points to his longer book 'Gist of Go: Concurrency' for the full curriculum. That honesty is appreciated. The coverage is genuinely comprehensive for a 'mini-book.' Eighteen topics spanning goroutines through diagnostics and scheduling means most working Go developers will find at least two or three sections that clarify something they'd been fuzzy on. The pipeline patterns — output channels, done channels, cancel channels — are particularly well-presented as composable building blocks rather than isolated recipes. As a reference artifact, this sits in a sweet spot: too structured for a blog post, too compressed for a textbook, and more interactive than a PDF. It's the kind of resource you bookmark and return to when you're staring at a goroutine leak at 2 AM and need to remember whether closing a nil channel panics. (It does.)
