The Writing Tool That Wrote Its Own Book

I wrote a book in 18 days about a tool I built in 18 days. The tool was used to write the book.

That sentence sounds like a riddle. It isn't. It's what happened.

The itch: writing should feel like recording

I am a musician. For years I spent money and time getting my studio set up so I could hit power and record. No configuration. No fiddling. Just create.

I always wanted writing to feel the same way. But writing has overhead that music doesn't. Character profiles. Story bibles. Beat sheets. Premises. Theses. Outlines. The actual prose is only part of the work. Before you write a single sentence, you need a stack of supporting documents that keep the story consistent and the structure sound. Managing all of that by hand, across files and folders, was enough friction to keep me from starting.

I wanted a tool that handled the scaffolding so I could focus on the writing. The same way my studio handles routing and signal chain so I can focus on the music.

A screenplay broke it open

A friend sent me an outline for a screenplay. It was rough and alive. The kind of outline that has personality because the person behind it is a person. Half-finished sketches at the end, shorthand descriptions, real energy in the early scenes.

I used Claude to help me draft some scenes. The AI was fast. It was also sloppy in predictable ways. Weather descriptions before every scene. Three adjectives per noun. Atmospheric filler in places that needed action. The outline had a character walking into a scene and doing something specific. Claude's version had the sun rising over palm trees before anyone did anything at all.

The structure was fine. The craft wasn't. And I noticed that the problems were the same every time. Not random mistakes. Habits.

I started making rules. Cut the weather. One adjective per noun. Direct verbs only. The output tightened immediately. Not because the AI got smarter. Because I gave it boundaries.

That was the discovery. The useful rules weren't about what to do. They were about what to stop doing. I didn't ask for "punchy prose." I told it to stop decorating. The quality showed up on its own once the clutter was gone.

And I thought: what if those rules were built into the tool? Not as suggestions I paste into a prompt every time, but as architecture. What if the assistant already knew what good craft looked like before I started a session?

So I built the tool

DraftDesk.io is a desktop writing assistant built with Electron and Next.js. Instead of calling Claude's API directly, it wraps the Claude Code terminal inside the app. That means I can use my existing Claude subscription for all the writing intelligence without racking up API costs. The only API expense is ChatGPT's text-to-speech.

The build took 18 days. January 25 to February 12, 2026. Thirty-four commits. Every line of the app's 7,400 lines of TypeScript was co-authored by Claude Code.

The app's job is to handle everything around the writing so the writer can focus on the writing. You open a project and the supporting documents are already organized: character profiles, beat sheets, story bibles for fiction. Thesis, audience, chapter outlines for nonfiction. The scaffolding is there before you type a word.

When you do write, the AI assists. It can help draft scenes, suggest revisions, continue where you left off. But the writer makes the calls. The tool's real value isn't generating text. It's keeping the text honest.

The constraint system: an editor that never sleeps

This is the part that surprised me most.

When AI helps you write, the biggest risk isn't that it produces bad work. It's that it produces work that looks fine on the surface but has no craft underneath. Polished sentences. Flat structure. Safe choices everywhere. The kind of writing that passes a grammar check and fails a reader.

So I built a constraint system into the assistant. Think of it as a set of craft rules that the tool enforces automatically, like a co-editor who catches the habits you'd catch yourself if you weren't tired.

Vocabulary guardrails. A list of banned phrases built from patterns I kept seeing in AI-assisted drafts. Crutch phrases. Passive constructions that erase character agency. Emotional shorthand that means nothing. When the tool catches one, it forces a more specific choice. That's the kind of nudge a good editor gives you: not "write better," but "this phrase is doing no work, replace it."

Style rules. Restraint over decoration. Clarity over beauty. Trust the reader. One adjective per noun. These are baked into every interaction with the AI, so the assistance you get back already reflects the craft standards you set.

A three-pass workflow. When the tool helps with a longer section, it separates the work the way a professional process would. First pass: plan the structure. Build a blueprint with beats, arcs, argument flow. Second pass: draft the prose against that blueprint. Third pass: review the draft against the plan and flag where it fell short. The writer sees the blueprint before any prose gets written and can reshape it. The writer sees the review after and decides what to fix. The AI handles the tedious comparison work. The creative decisions stay with the human.

Mechanical enforcement. Some AI habits are stubborn enough that no amount of prompting fixes them. For those, the tool runs cleanup functions on the output before the writer ever sees it. Not rewriting. Just removing tics that shouldn't be there. The same thing a copy editor's find-and-replace would catch.

The whole system exists because I believe the writer should be in control. AI is a powerful assistant, but left unsupervised it defaults to safe, decorative, and predictable. The constraints don't limit the writer. They limit the assistant.

From fiction to nonfiction in one commit

The constraint system was built for screenplays and tested on a novel. On February 12, one commit brought nonfiction to parity. 755 insertions, 90 deletions, across twelve files.

The supporting documents changed: character profiles became thesis and audience documents. Beat sheets became chapter outlines. The structural workflow stayed the same. Plan it, draft it, review it.

The fiction workflow asks "did the character arc land?" The nonfiction workflow asks "does this argument hold?" Different questions. Same discipline.

The book

Then I needed to test whether the system worked for real. Not test scenes. Not sample chapters. A full manuscript.

So I wrote a book about how I built the tool. Using the tool.

I did the writing. The tool managed the scaffolding, enforced the craft rules, and kept the structure accountable. The same vocabulary guardrails that cleaned up the screenplay work governed the book's prose. The same three-pass workflow organized its chapters. The nonfiction mode shipped the day before I needed it.

A system built to help me write was now helping me write about itself. The book is called The Recursive Collaborator: How I Used AI to Build an AI Writing Tool in 18 Days.

What I keep coming back to

The lesson that stuck isn't about AI capability. The models are capable enough. What they lack is taste. They don't know when to stop. They don't know what good looks like for your project, your voice, your genre.

That knowledge lives in the writer's head. A tool can encode it. Rules can enforce it. But someone has to define it first.

The models don't need more freedom. They need walls. And the person who builds the walls is still the one doing the creative work.

18 days. One developer. One AI assistant. 7,400 lines of code and a finished manuscript. Not because AI did the thinking. Because I built a system that kept the AI useful and stayed out of my way while I wrote.

Stack

Electron · Next.js 15 · TypeScript · Claude Code · ChatGPT TTS API