Swizec Teller - What I learned writing a lousy tech book
Based on Write the Docs's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Teller’s book-writing process relied on a tight loop: choose a simple, meaningful example, code it to verify it works, then write the explanation around the working result.
Briefing
A tech author’s path from blog post to published book turned into a lesson in how nonfiction quality gets shaped—often painfully—by contracts, deadlines, and layers of editing. After landing a deal to write a visualization-focused JavaScript book, Swizec Teller spent roughly 770 hours over about 66 days producing an initial manuscript, only to have the publisher demand major changes: the book needed to be shorter, more consistent, and more technically correct. The result was a book that Teller ultimately described as “awesome,” but only after multiple full rewrites and months of structural and technical feedback.
The story begins in 2012 after Teller posted early experiments with d3.js, a JavaScript library for visualizations. A recruiter-like email arrived from an Indian contact pitching a book opportunity to teach others how to draw “pretty pictures.” Teller accepted despite having never written anything longer than a blog post. The contract process took two months, with the publisher taking copyright control and limiting Teller’s ability to reuse material—he estimated he could quote only about 10% under fair use. The deal also included a “right of first refusal” clause, meaning any future book proposals had to be reviewed by the publisher first.
Writing itself followed a repeatable cycle: build a meaningful, simple example from the API documentation, code it to prove it works, then write the explanation around that already-working code. Teller emphasized that the hardest part was choosing the first chapter’s example—everything must be explainable, exercise the right parts of the technology, and avoid relying on concepts that will only appear later. He credited the quality of open-source documentation (specifically d3.js) for helping him learn quickly enough to write.
The first major disruption came from length. Teller delivered about 180 pages when the target was around 120, and the publisher pushed for a reduction of roughly 60 pages. That forced a near-total rewrite: he preserved the core content but removed jokes, stylistic turns of phrase, and other personality-heavy language to make the book shorter and clearer. He also had to correct errors flagged by editors, including technical mistakes that required sending chapters back repeatedly.
Even after the manuscript was “done,” technical editors returned with feedback that required further changes—examples that didn’t work as described, incorrect ordering of concepts, and explanations that didn’t match how the code actually behaves. Teller resisted some structural changes because he was exhausted, and he later suggested that this fatigue likely contributed to the book ending up “a bit crappy” in places, even if the most engaging examples kept him sane.
The final stages included copyediting and production checks—ensuring acronyms were used consistently, code introductions were clear, and printed formatting fit the page. Marketing, however, remained opaque: Teller received royalty reports but no visible buzz or measurable impact. His takeaway was blunt: publishing is hard, editors can be relentless, and the economics can be underwhelming, but getting through the process is a remarkable achievement. He also contrasted traditional publishing with self-publishing, arguing that self-publishing can be more flexible and potentially more profitable, yet requires discipline to actually finish.
Cornell Notes
Swizec Teller’s experience writing a tech nonfiction book shows how quality is negotiated through contracts, deadlines, and layered editing. After starting with a d3.js blog post, he accepted a publisher deal despite having never written a long-form book. He built the manuscript through a cycle of choosing a simple, meaningful example, coding it, then writing explanations around working code. The publisher later demanded a major reduction in length and multiple rewrites, while technical editors corrected broken examples, wrong concept ordering, and mismatches between explanations and code behavior. Teller credits open-source documentation for enabling learning, but he also notes that marketing visibility was limited and the time cost was enormous.
How did Teller go from a short d3.js blog post to a full book contract?
What was Teller’s practical method for writing technical chapters?
Why did the publisher force a rewrite, and what changed in response?
What kind of feedback came from technical editors after the manuscript was nearly finished?
How did Teller compare traditional publishing with self-publishing?
Review Questions
- What constraints in Teller’s contract affected his ability to reuse or expand his work later?
- Walk through Teller’s chapter-writing cycle and explain why coding first mattered.
- What specific types of problems did technical editors correct, and how did that influence the final manuscript?
Key Points
- 1
Teller’s book-writing process relied on a tight loop: choose a simple, meaningful example, code it to verify it works, then write the explanation around the working result.
- 2
Open-source documentation (d3.js API docs) was a key learning tool that enabled Teller to move from blog-level experimentation to book-level instruction.
- 3
Publisher control and contract terms (copyright ownership, limited quoting, and right of first refusal) shaped what Teller could do with his own material.
- 4
A major length mismatch triggered a near-total rewrite, with humor and stylistic “personality” trimmed to meet page targets.
- 5
Technical editors corrected not just typos but conceptual accuracy—broken examples, wrong ordering, and mismatches between explanations and actual code behavior.
- 6
Even after production, marketing impact was hard to measure from the author’s perspective, despite regular royalty reporting.
- 7
Teller’s self-publishing advice emphasized discipline and reader-funded momentum: release early, raise prices as the book grows, and assemble freelance editorial help.