The rest of this series is a diagnosis. Seven articles on everything wrong with machine writing, from the inflated word at the surface down to the one spine the machine uses every time. If you have read them, you might reasonably conclude the answer is to never let AI near your fiction. That is one answer, and it is a respectable one. But it is not mine, because the tool is genuinely useful, and the problem was never the tool. The problem was using it without a method. This article is the method.
Anyone promising you a finished book at the push of a button is selling the hollow thing this whole series is about, and I think those people do real harm to the writers who trust them. AI is a tool. Treat it like one and it’ll save you time on a book that’s still yours, in structure, voice and nerve. Let it make the decisions and you’ll end up with a manuscript nobody wants to finish.
First, the outline, and make it thorough
Before you generate a word of prose, you write the outline, and you write it in detail. Not a logline, not a vague three-act sketch. A real chapter-by-chapter outline of the book you intend to write, with each chapter’s job, its events, its turns, what changes in it, what it costs. The more specific the better. If you know a chapter ends on a particular image, put it in. If you know a character loses something in chapter nine that they had in chapter two, write that thread into both places.
This does two things, and the first is the one people miss. A thorough outline is the single best defense against drift. Recall from the drift article that the machine loses the thread over length, contradicting its own facts and forgetting its own threads, because it does not hold the whole story, it holds a window. The outline is the thing it can hold. The machine is very good at following a specification. Give it a detailed one and it has a pattern to work against, a fixed reference that does not erode the way its own memory of earlier chapters erodes. The eye color stops changing because the outline says what color the eyes are. The dropped thread stops getting dropped because the outline is holding it even when the machine is not. You are supplying the continuity the machine cannot supply itself.
The second thing the outline does is force you to own the structure. Every problem in the spine article, the uniform chapters, the unpaid stakes, the tameness, the one spine used every time, all of it comes from letting the machine decide the shape. When you build the outline yourself, you make the structural decisions the machine would otherwise make badly. You decide where the stakes get paid and what they cost. You decide which chapter is short and brutal and which is long and slow. You decide that the antagonist has a real case and that something stays broken at the end. The machine cannot impose its one spine on your book if you have already given the book a different spine, in the outline, before the machine ever sees it. The outline is where you win the spine, and the spine is the thing you cannot win any other way.
Skipping the outline is the most expensive shortcut in this whole process, and it’s the one I see sold hardest. The machine makes starting feel free, so writers start, and they’re halfway into a book with no spine before they notice anything’s wrong. Give me a writer who spends a month on the outline and a week on the drafting over one who does the reverse.
Then, the specification at the top
Above the outline, you put a block of instructions that does the heavy lifting on every layer above the spine. This is your specification: a standing set of rules telling the machine how to write, what to avoid, and how to vary what it would otherwise make uniform. You’re pre-loading the machine with everything this series taught you, so it doesn’t make the mistakes in the first place.
The specification has to be thorough, because the machine’s defaults are many and strong. You tell it the words and phrases to avoid, all of them, the whole banned list from the word article, the inflated descriptors, the soft abstractions, the stock phrases. You tell it no em dashes. You tell it to vary sentence length deliberately, short against long, because left alone it clusters everything at one medium length. You tell it to vary paragraph shape and length, because left alone it builds every paragraph the same way and runs them all to the same size. You tell it to vary chapter length and structure, because left alone it makes every chapter the same container. You tell it not to have characters watch themselves, not to explain emotions it has already shown, not to end every chapter on a soft hook of significance. You tell it to let dialogue be ragged, to let details go nowhere, to stay in the hard moment instead of cutting away.
That’s a lot to specify, and writing it the first time is a pain. You’re translating the whole diagnosis of this series into standing orders. You only write it once. The banned words, the orders to vary structure, and the rules about self-watching characters, clean dialogue and tame scenes stay the same for every book. You refine it as you learn what your machine slips on, carry it from project to project, and only the outline changes. I’d call that the best trade in the whole method.
Then, one chapter at a time
With the specification written and the outline detailed, you generate the book one chapter at a time, never more. This matters, and it matters because of drift.
The longer a single generation runs, the worse the drift, the more the voice erodes back toward the machine’s defaults, the more the facts slip. A chapter is short enough that drift barely starts. So you generate one chapter, against its specific outline entry, with the specification at the top of the prompt holding the rules in place. Then you stop. You read it, you fix what needs fixing, and only then do you generate the next one, again with the specification fresh at the top, again against the outline. By resetting the rules at the start of each chapter and never letting a generation run long, you keep the specification’s grip from eroding and you keep the drift from compounding. You are working with the grain of the tool, using it at the length where it is strong and refusing to use it at the length where it falls apart.
This also keeps you in control of the structure chapter by chapter. Because you are working against an outline you built, each chapter has a job you assigned it, not a job the machine improvised. The chapter that should be short and devastating gets generated short and devastating, because the outline said so and the specification told the machine to vary length. The machine is filling in prose against your structure, not inventing its own, which is exactly the division of labor that works: the machine drafts, you architect.
Generating a whole book in one sitting because the tool allows it is how writers end up with a manuscript that contradicts itself from one chapter to the next, and they usually find out when a reader does. I think the companies selling these tools should say so a lot louder than they do.
Which pass do you still have to make yourself?
Even with a good specification and a chapter-at-a-time process, the machine will still slip, and you still read every chapter against everything this series taught you. The specification reduces the tells, it does not eliminate them. The machine will still occasionally reach for an inflated word, still occasionally cluster its sentences, still occasionally have someone watch themselves. Your job, chapter by chapter, is to catch what got through.
But notice how much smaller that job is than fixing a machine draft you let run wild. When you generate a whole book with no specification and no outline and then try to clean it, you are playing the whack-a-mole game from the why-it-feels-wrong article, every fix surfacing the next, forever, with the unwinnable spine underneath. When you work this way, the spine is already right because you built it in the outline, the worst tells are already suppressed because the specification told the machine to avoid them, and what is left for your pass is the residue, the few moles that got through a board you already controlled. You are editing prose, not rebuilding a structure. That is a job that ends.
What is the division of labor here?
Step back and look at what the method does, because the shape of it is the whole point. It splits the work into the part the machine is good at and the part only you can do, and it gives each part to the right one.
The machine is good at generating fluent prose against a specification, at chapter length, fast. That is real and it is useful, and the method uses it fully, for exactly that. You are good at the things the machine cannot do: deciding what the story is, what it costs, what shape it takes, what stays broken, where it goes that a machine would flinch from. Those are structural and they are nerve, and the method keeps every one of them in your hands, in the outline and the specification and the pass. The machine never touches the spine, never decides the structure, never chooses what the book refuses to do. It just drafts the prose, against your plan, under your rules, one chapter at a time, and then you make it yours.
My own handbooks use AI at the other end of the job. The 40-plus writing handbooks give writers prompts to build a better protagonist and a stronger plot, and none of them asks the machine to write the book. It’s the same division this method makes: the tool helps you think, and you make the calls.
This is the answer to the question the series has been building toward. You do not use AI to write your book. You use AI to draft prose for a book you are writing, where the writing, the real writing, the deciding and the structuring and the willingness to make it cost something, stays yours from the first outline entry to the last pass. Done that way, the tool earns its place and produces none of the hollowness, because the hollowness was never in the prose. It was in letting the machine make the decisions. Take the decisions back, give it only the drafting, and you have something that works.
What goes into a specification for writing with AI?
It helps to see the shape of one, so here is what a working specification covers, in plain terms. This is not a template to copy, because yours should be built from your own reading of this series and refined against your own machine’s habits, but it shows the territory.
It opens with the voice. A few sentences describing how the prose should sound, the register, the level of formality, whether it is plain or ornate, sparse or dense. This anchors the machine before the rules start. Then the banned list, the longest part, every word and construction from this series that you do not want: the inflated descriptors, the soft abstractions, the stock phrases, the hedges, the throat-clearing, the gerund openings, em dashes, the rule of three, the not-just-but construction. You list them because the machine reaches for them by default and only an explicit ban suppresses them.
Then the structural instructions, which are the ones people forget and which matter most above the spine. Vary sentence length deliberately, with short sentences for impact and the occasional fragment, never a uniform medium cluster. Vary paragraph length and shape, never the same architecture twice in a row, sometimes a single line, sometimes a long build, never the announce-develop-restate pattern. Vary chapter length according to what the chapter does, not a word count. Do not end chapters on a soft hook of significance. These are the orders that break the uniformity the machine imposes when left alone.
Then the scene-level rules. Characters do not watch themselves from the outside. Emotions are shown, not named after they are shown. Dialogue is allowed to be ragged, interrupted, evasive. Details are allowed to go nowhere. Stay in the hard moment, do not cut away from violence or grief or sex, do not flinch. These translate the scene and content cowardice articles into standing orders.
And finally the continuity anchors, the fixed facts the machine must not drift on, pulled from your outline: names, physical details, the timeline, the threads that must pay off. You restate the critical ones at the top of each chapter’s prompt so the machine has them fresh and cannot slip. That single habit, carrying the key facts forward into every generation, kills most continuity drift on its own.
Continuity errors make me angrier than almost anything else in a published book, because they’re the cheapest failure to prevent. A reader who watches a character’s eyes change color stops trusting the author, and the author could’ve stopped it with one line at the top of a prompt.
The specification is that short, and you can feel how it is just this series turned into instructions. Which is the point. The diagnosis and the method are the same knowledge, pointed two directions: backward, to catch what the machine did, and forward, to stop it from doing it. Once you have the second one written, you stop needing the first one nearly as much, because the tells never form.
What’s the short version of the method?
Build a thorough outline first, because it is your structure and your defense against drift. Put a complete specification above it, every banned word and every instruction to vary what the machine makes uniform, and know that you write it once and reuse it on every book after. Generate one chapter at a time against the outline, with the specification fresh each time, so drift never compounds and the rules never erode. Then read every chapter against this series and catch what slipped, which will be little, because you controlled the board from the start.
It’s more work than the fantasy of a book in a weekend, and far less than the misery of fixing a machine draft that ran wild. It also produces a book worth reading, because the decisions stayed yours the whole time. I’m sick of the weekend-novel pitch and the people selling it to writers who deserve better. Keep the book, let the machine do the typing, and you’ll have something you can put your name on without wincing.
The series: this is the constructive end of the whole thing. Go back to the hub for the full diagnosis, or see it all demonstrated in the annotated machine story and the rebuilt version that shows what taking the decisions back actually looks like.
