So how do you write using AI?

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.

I want to be honest about what this does and does not promise. It will not let you push a button and get a finished book. Nothing will, and anyone selling that is selling the hollow thing the rest of this series is about. What the method does is let you use AI to draft a book that is yours, with your structure, your voice, and your nerve, while spending the machine’s help where it actually helps and refusing it where it does damage. It is more work than the fantasy and far less work than fighting a machine draft you let run wild. Here is how it goes.

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.

Then, the specification at the top

Above the outline, you put a block of instructions, and this is the part 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 are, in effect, pre-loading the machine with everything this series taught you, so it does not 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 is a lot to specify, and writing it the first time is genuinely a pain. I will not pretend otherwise. You are essentially translating the entire diagnosis of this series into a set of standing orders, and it takes a while to get it complete. But here is the fortunate part, the thing that makes the whole method worth it: you only write the specification once. It is reusable. The banned words are the same for every book. The instructions to vary structure are the same for every book. The orders about self-watching characters and clean dialogue and tame scenes are the same for every book. You build the specification one time, you refine it as you learn what your particular machine slips on, and then you carry it from project to project. The only thing that changes book to book is the outline. The specification stays, and over time it gets better, and the work of writing it amortizes across everything you ever write.

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.

Then, the pass you still have to make

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 this division of labor actually is

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.

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 a specification actually contains

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.

That is the whole specification, 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.

The honest summary

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 is more work than the fantasy of a book in a weekend. It is far less work than the misery of fixing a wild machine draft, and unlike that misery, it actually produces a book worth reading, because the book was yours the whole time and the machine only ever held the pen. That is how you write using AI. Not by handing it the book. By keeping the book and handing it the typing.

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.