Get AI summaries of any video or article — Sign up free
Swizec Teller - What I learned writing a lousy tech book thumbnail

Swizec Teller - What I learned writing a lousy tech book

Write the Docs·
5 min read

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.

TL;DR

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?

He wrote an early blog post about experimenting with d3.js, then received an email from a recruiter-like contact pitching a book opportunity. Teller had never written anything longer than a blog post, but he agreed after quickly learning from the d3.js API documentation and drafting an outline. Contract work took about two months, and the publisher took copyright control, limiting Teller’s reuse rights (he estimated he could quote only about 10% under fair use).

What was Teller’s practical method for writing technical chapters?

He followed a repeatable loop: pick an example that’s interesting and meaningful, keep it simple enough to explain, and ensure it exercises the exact parts of the technology being taught. He then coded the example to prove it worked, which took days because d3.js is complex. Only after the code worked did he write—embedding the code and describing the output in plain language, then iterating chapter after chapter.

Why did the publisher force a rewrite, and what changed in response?

The delivered manuscript was far longer than the target: about 180 pages versus roughly 120 max. The publisher asked for a reduction of around 60 pages, so Teller effectively rewrote the book again. He removed jokes and stylistic flourishes, polished language to be simpler, and tried to preserve content while tightening explanations and structure.

What kind of feedback came from technical editors after the manuscript was nearly finished?

Technical editors flagged issues that went beyond wording: examples that didn’t actually work as described, incorrect ordering of concepts, and explanations that didn’t match how the code behaves. Teller resisted some structural changes because he was exhausted, which he later suggested may have left some parts less polished than they could have been.

How did Teller compare traditional publishing with self-publishing?

He described traditional publishing as more fun and potentially more lucrative, but with a risk of never finishing due to external schedules and persistent editorial demands. For self-publishing, he recommended keeping writing while publishing (e.g., releasing chapters/early versions), bootstrapping with reader support instead of advances, and using pricing that increases as the book grows to reward early readers. He also suggested hiring freelance editors online to build an editing team.

Review Questions

  1. What constraints in Teller’s contract affected his ability to reuse or expand his work later?
  2. Walk through Teller’s chapter-writing cycle and explain why coding first mattered.
  3. What specific types of problems did technical editors correct, and how did that influence the final manuscript?

Key Points

  1. 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. 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. 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. 4

    A major length mismatch triggered a near-total rewrite, with humor and stylistic “personality” trimmed to meet page targets.

  5. 5

    Technical editors corrected not just typos but conceptual accuracy—broken examples, wrong ordering, and mismatches between explanations and actual code behavior.

  6. 6

    Even after production, marketing impact was hard to measure from the author’s perspective, despite regular royalty reporting.

  7. 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.

Highlights

Teller delivered about 180 pages when the target was around 120, and the publisher demanded a 60-page reduction—forcing a rewrite that removed jokes and stylistic flourishes to tighten clarity.
The hardest part of writing the first chapter wasn’t coding; it was selecting an example that was simple, meaningful, and teachable without relying on future concepts.
Technical editing went deep: editors challenged example correctness and even the order of concepts so the explanation matched how the code actually behaves.
Teller credited d3.js open documentation for making rapid learning possible, but he still spent roughly 770 hours across about 66 days to reach an initial draft.
Marketing remained opaque to the author, with no visible buzz despite quarterly royalty reporting and a relatively small sales figure.

Topics

Mentioned

  • Swizec Teller
  • API