Thinking in Python: Bruce Eckel Revives His 2008 Book With Claude in 2026

Bruce Eckel wrote the books a generation of developers learned from: Thinking in Java and Thinking in C++ taught mental models, not just syntax. He started a Python version of the series in 2008, abandoned it in 2011 with many of the design patterns chapters still written in Java, and publicly said he was never going to finish it. This week the finished book is live at thinkinginpython.com: "Thinking in Python - Insights, Idioms and Patterns," a free 47-chapter read that targets Python 3.15, and the reason it exists is Claude.

What the book actually is#

The structure is five parts. Part I is a fast foundations tour for programmers coming from other languages, with static typing singled out as the one chapter the rest of the book assumes. Part II covers the idioms that give Python its character: testing, data classes as types, pattern matching, decorators, context managers, comprehensions, metaprogramming, and a performance-plus-concurrency closing pair. Part III reinterprets the classic design patterns for Python and weighs each against the language, on the book's central question: does Python already solve the problem the pattern exists for? The introduction makes the thesis concrete: a Singleton is a module, a Visitor is a function that dispatches on type, and complexity should only be added when the language has no answer. Part IV moves into functional programming, including errors returned as values instead of raised exceptions, and Part V finishes on effects, culminating in the stateless library that brings effect tracking to Python today.

The book targets Python 3.15 and later, uses type hints throughout after the typing chapter, and tests with pytest. The standout engineering claim is the build system: examples are extracted from the source files, then type-checked with Astral's ty, linted, run, and tested, and the output you see in listings is written by the build as #: markers from a real run, so it cannot drift from what the code prints. Every chapter's examples and exercise solutions live in the GitHub repository with uv-based setup, which means the book is reproducible end to end. The license is CC BY-NC-ND 4.0: free to read, but no derivatives and no commercial reuse.

The AI disclosure and how the book came back#

Eckel's introduction is unusually direct about the method. He started the book in 2008, abandoned it in 2011, and in June 2026 decided to see what Claude could do with the existing material. Claude brought it up to Python 3.15, added type annotations, passed standards checkers, and cleaned up prose, and Eckel then went back through his PyCon presentations and blog posts to integrate more of his own work. He describes the process as directing rather than acting: "the director of the movie instead of an actor in it," with every sentence gone over multiple times. The line that will settle most arguments is the one about the tool: without Claude, he writes, the book would not exist; it is free, so readers bothered by AI are free to ignore it. Since August 12 he has been running a post-AI edit loop documented in the repository: edit a chapter, derive guidelines from the edits, apply those guidelines across the book, repeat.

Two details in that write-up are worth more than the disclosure itself. One is that the method enabled ideas that had been deferred for years, like automatically interleaving commented output in listings, which the book now does by construction. The other is his closing observation that the book's knowledge helps him guide AIs toward better solutions, which reframes a reference text as a control surface for AI-assisted work, not a rival to it.

What developers are saying#

The strongest and most common reactions are nostalgia plus a live argument about AI authorship. Older readers land on the Thinking in Java years and describe what made the series effective: it built mental models of the language instead of enumerating syntax, and the question is whether this new volume carries that tradition. Feedback on the book's distinctive content is specific and positive, especially the effects chapters, which reviewers call genuinely novel for the Python world and a look at where Python's type system is heading.

The AI debate splits cleanly into the two positions the disclosure was written to preempt. One camp holds that anything AI-generated is slop by default and the moral origin matters more than the result. The other, larger camp argues the useful distinction is not who wrote it but whether it was edited, and treats the book as evidence: the formatting is unusually clean, the examples run, and the author's openness about the process and his visible post-AI edit checklist make this a very different artifact from unedited generated content. A smaller set of criticisms is technical: Python 3.15 is still in prerelease, so targeting it is a statement about the near future rather than current stable; the NC-ND clause blocks the remixes and translations free culture normally gets; and e-reader users note the book ships web-first, with the epub buildable from the repo but not linked from the site.

Why this matters for developers#

This is the cleanest published example yet of the "AI as director, human as editor" workflow on a long-form project, and it is priced at zero, so it is worth reading for the method even if Python is not your language. Three things generalize.

First, the build-verified examples are the pattern to steal. When output markers are regenerated from actual runs, forgetting to update a listing becomes impossible, which is the same discipline that makes example code in any reference trustworthy. Second, the design-pattern reframing is the book's intellectual core and it transfers to any language: before implementing a pattern, ask whether the language already dissolves the problem. Third, the honest disclosure plus a public edit log is a template for AI-assisted work at any scale - it converts the authorship question from an accusation into an inspectable process.

The book assumes an experienced programmer and reads like a conversation with someone who has taught this material for decades. If you want to see what one of the most influential technical authors of the internet era could not do without AI but could direct with it, this is the artifact to study.

Continue Reading#

• A Free Compilers Textbook That Actually Teaches You to Build One - another free, high-quality technical book that rewards study over skimming
• Don't Paste the AI Slop: Tools Compared for Keeping Generated Code Clean - the editing-vs-slop debate, applied to code generation tooling
• AI Design Slop: 16 Patterns That Out Your App as Vibe-Coded - what unedited AI output looks like, for contrast with a heavily edited book
• Claude Cookbook: Anthropic's Official Playbook for Building with Claude - the vendor's own structured approach to the same technology
• Scarf: A Haskell Codebase Migration That Used an LLM as the Translator - AI-assisted language work on a real open-source migration

Sources#

• Thinking in Python, home page and full text (Bruce Eckel)
• Thinking in Python, Introduction chapter with the AI disclosure
• Thinking in Python source repository (GitHub)