Teiva Harsanyi's 100 Go Mistakes and How to Avoid Them approaches the audiobook format with a clarity unusual in technical publishing. Most programming books recorded for audio lose their usefulness the moment a code listing appears. This one, narrated by Christopher Kendrick over just under twelve and a half hours, manages the translation more gracefully than its peers because Harsanyi has organized his material into conceptual categories rather than line-by-line syntax, and Kendrick has the technical confidence to deliver that content without making it feel like a recited manual. The PDF companion included with the purchase is genuinely necessary for any listener who wants to review specific examples, but the audio layer carries real substance on its own.
The book's premise is clean: understanding the mistakes you are making, including the ones you are not aware of, is the fastest path to better code. Harsanyi organizes 100 bugs and inefficiencies into categories covering types and strings, data structures, control flow, error handling, concurrency, and testing. That structure means each section has a natural listening arc rather than feeling like a random catalog of warnings. Reviewers have called this essential for intermediate Go developers, and that framing is accurate - beginners will lack the context to fully absorb some of the concurrency material, while senior developers may find the earlier sections familiar but will still profit from the later ones.
Kendrick's Narration Carries Go's Concurrency Bugs
The most valuable section for audio listeners is the concurrency coverage. Concurrency bugs are notoriously difficult to reproduce and diagnose, and Harsanyi's explanations of what goes wrong and why are articulate enough to work without a whiteboard. He is not just listing bad patterns; he is explaining the reasoning behind why Go's memory model makes certain mistakes predictable, and that explanatory approach carries well through Kendrick's narration.
The JSON and HTTP services material is equally effective in audio. These are areas where Go developers regularly write technically correct code that behaves incorrectly under load or with unexpected input, and Harsanyi is specific about failure modes. The organization structure - ranging from types and strings through to testing quality - means listeners can use the table of contents to navigate to the sections most relevant to their current work rather than processing all twelve hours in one sustained effort.
Every Explanation Earns Its Place in Real Time
What separates this audiobook from a blog post compilation or a style guide is Harsanyi's commitment to explanation over assertion. He does not simply list what not to do. He builds the case for why each mistake is a mistake - what assumption underlies it, what Go-specific behavior it misunderstands, and what the idiomatic alternative looks like. That difference matters enormously in audio because listeners cannot skim. Every explanation has to earn its place in real time, and the ones here consistently do.
Reviewer Michael Freeman notes wishing he had picked this up earlier, while another reviewer placed it alongside Go in Practice as the definitive pair of Go books for working developers. That is not casual praise. The 4.8 rating across 147 reviews suggests a consistency of usefulness that few technical audiobooks achieve. For Go developers who have moved past tutorials and want to pressure-test their assumptions, twelve hours with Harsanyi is a productive investment.
Reviewer kiwiendeavour, who opened their programming career in assembly and C before arriving at Go, places this alongside Go in Practice as the best pair of Go books available, noting that Harsanyi provides the clear detailed explanations using actual lines of code that cement the underlying reasoning. That specific praise - code that explains rather than merely illustrates - identifies what Kendrick's narration has to work with. The audio does not show you the code, but it delivers the logic, and the logic is where Harsanyi's real teaching lives.
Slice Misuse and Goroutine Leaks Need the PDF
The PDF companion is not optional for any listener who wants to retain the specific syntax examples. Kendrick reads code listings with clarity, but the patterns Harsanyi describes - slice misuse, goroutine leaks, context propagation errors - are easier to internalize when you can see the comparison between the problematic and the corrected version. Plan to use both formats: audio for the conceptual explanation while driving or exercising, PDF for the follow-up review when you have a screen available.
The book's scope is comprehensive, but that breadth means some sections pass quickly. The testing chapter, for instance, covers a lot of ground in relatively few pages - table-driven tests, benchmarking, race detection - and listeners who want to go deep on any single testing pattern may find the coverage motivating but not exhaustive. This is not a weakness so much as an honest description of what a hundred-mistake catalog can accomplish; it maps the territory without always providing a detailed survey of each acre.
Six Months to Three Years of Go Experience
This audiobook is best suited to Go developers with six months to three years of practical experience who want to close the gap between working code and idiomatic code. It will also benefit developers coming from other languages who are surprised by Go's specific behaviors around concurrency, error handling, or slice mechanics. Skip it if you are still learning Go fundamentals or if you want a deep architectural guide rather than a patterns-and-pitfalls reference. And if you purchase it, download the PDF companion immediately - the audio is richer when you know the visual reference is there when you need it.
