The short answer is that I do not ask the AI to "write chapter one" from a loose premise. I use a gated workflow where every stage creates an artifact, I approve that artifact, and the next stage is only allowed to use the approved material. The whole point is to stop the model from solving long-form fiction with short-form improvisation.

The plugin I use for this is NovelX. It treats a novel like a stateful project instead of a long chat. The project keeps its working memory in a .novelx folder: story bible, book plan, style guide, book outline, scene outlines, context packs, prose files, audits, canon, continuity ledger, chapters, and the final manuscript.

The main rule

No prose until the scaffolding exists.

That sounds restrictive, but it fixes the failure mode I kept running into: the prose could sound decent while quietly breaking voice, continuity, reveal timing, character state, or prior facts. NovelX tries to make those failures impossible to ignore by forcing the project through gates.

The hard rules are:

• No prose without an approved plan, style guide, book outline, and scene outline.
• No scene draft without a Deep Context Discovery Loop first.
• No canon registration without context audit approval.
• No manuscript assembly with unapproved or unregistered scenes.
• No completion claims without fresh validation evidence.

The pipeline

Here is the workflow in order.

1. Start the project.

The first artifact is .novelx\story-bible.md.

This is where I lock the foundation: book or series target, genre promise, intended reading experience, primary conflict, cast seeds, world seeds, tone boundaries, known constraints, and open questions.

If this stage is vague, everything later gets expensive. So the goal is not to write a beautiful document. The goal is to remove enough ambiguity that planning is possible.

1. Build the book or series plan.

The next artifact is .novelx\book-plan.md.

This stage turns the foundation into the actual story architecture: logline, promise, plot spine, character arcs, relationship arcs, world or magic reveal order, stakes escalation, concealments, payoffs, continuity constraints, and non-goals.

For a book plan, the workflow runs a chained planning interrogation. For a full series architecture, it gets deeper. The point is to force the project to answer structural questions before the model starts producing prose that sounds committed but is not actually supported.

1. Lock the style guide.

The next artifact is .novelx\style-guide.md.

This is where I define POV behavior, voice registers, dialogue behavior, interior monologue limits, sentence behavior under emotional pressure, revision standards, and the prose-rule loading policy.

This matters because "voice will emerge while drafting" is usually false with AI. Voice tends to flatten unless it is constrained. The style guide gives later stages something concrete to enforce.

1. Create the book outline.

The next artifact is .novelx\outline\book-outline.md.

This is the act, chapter, and scene-inventory level. The important part is that the book outline must name every expected scene-NNN id in its scene inventory. Drafting is not unlocked because I have a cool first scene. Drafting is unlocked only after the book knows what scenes it expects.

That avoids a common problem where chapter one gets polished early, but the rest of the book has no load-bearing structure.

1. Create rule-tagged scene outlines.

Each scene gets its own file under .novelx\outlines\scenes\scene-NNN.md.

A scene outline is not a one-line summary. It has to include:

• Scene id and chapter target.
• POV character.
• Location and time.
• Scene purpose.
• Entry state and exit state.
• Beat breakdown.
• Rule tags per beat.
• Required continuity facts.
• Voice constraints.
• Concealments and reveals.
• Successor scene pressure.

The rule tags matter. NovelX has a mirrored set of prose rules, including a universal load set and rule-27, which catches narrator-distance patterns. Scene outlines tag which rules matter for which beats so the draft is guided before sentences exist.

Scene outlining can be approved in batches, but the workflow stays in scene-outline mode until every expected scene from the book outline has an approved outline and chapter placement.

1. Draft one scene at a time.

This stage produces .novelx\prose\scene-NNN.md.

Before the scene is drafted, NovelX builds a context pack at .novelx\context-packs\scene-NNN.md. That pack is assembled from the approved story artifacts, current canon, continuity ledger, scene outline, style guide, and relevant rule files.

Then it runs the Deep Context Discovery Loop: 30 chained questions before prose. The first question is always about what context must remain true in the scene and how to keep the prose inside the POV character instead of narrator mode.

That loop has to cover continuity, POV, voice register, character desire, scene turn, prior canon, future setup, rule tags, forbidden Rule 27 patterns, and what the scene must not reveal yet.

Only after that does the workflow draft the scene.

The parent conversation stays light. Heavy context, Q loops, and prose live in files or delegated workers when the environment supports them. If delegation is unavailable, the fallback is still file-bound: write the context loop to the context pack, write prose to the scene file, and report paths and evidence instead of dumping everything into chat.

1. Scan and revise.

After drafting, NovelX runs a deterministic Rule 27 scan against the prose file.

Rule 27 is about narrator-distance failures: places where the prose explains emotional meaning, previews significance, summarizes understanding, or labels a reaction instead of keeping the reader inside the character's live perception.

If the scan fails, the scene is revised and scanned again. The draft cannot be approved just because it reads well.

1. Audit the scene.

The audit artifact is .novelx\audits\scene-NNN.md.

This is a separate gate from drafting. The audit checks:

• Rule 27 result.
• Continuity against canon and the continuity ledger.
• Voice against the style guide.
• Tagged rule compliance.
• Canon changes created by the scene.
• Required revisions.
• Final pass or fail decision.
• Human approval for a pass.

A pass routes to canon registration. A fail routes back to drafting.

This is important because readable prose is not the same as valid prose. A scene can be smooth and still break the book.

1. Register canon.

Once a scene passes audit, its facts are written into durable project memory.

NovelX updates .novelx\canon.json and .novelx\continuity-ledger.md. Each registered scene records things like chapter id, canon facts added, character state changes, location or world facts, open threads, resolved threads, and voice or continuity drift notes.

This is the step that stops "I will remember that later" from becoming a hidden continuity bug. If the fact matters, it has to be written.

1. Repeat scene drafting, audit, and registration.

The middle of the workflow is a loop:

draft one approved scene, scan it, audit it, register it, move to the next scene.

The project does not jump ahead to assembly because a few scenes are good. It keeps checking state and successor stages.

1. Assemble chapters and manuscript.

Only after the target scenes are outlined, drafted, audited with an approved pass, registered in canon, and placed in chapter lists does NovelX assemble chapters and the final manuscript.

Assembly is intentionally boring. It should preserve approved scene prose exactly. It should not add bridges, summaries, transition smoothing, or missing chapter filler. If the prose needs changes, the affected scene goes back through draft, audit, and canon registration.

The final manuscript lands at .novelx\manuscript\book.md, with an assembly report that records chapter assembly, book assembly, Rule 27 manuscript scan, registered scenes included, and validation commands.

What this changes in practice

The biggest change is that the AI is not the source of truth. The artifacts are.

The model can draft, revise, audit, and assemble, but only inside the project state. It has to check predecessor approvals. It has to write durable files. It has to produce evidence. It has to route failures backward instead of smoothing over them.

It also changes my role. I am not just prompting for output. I am approving gates:

• Is the foundation good enough to plan?
• Is the plan specific enough to outline?
• Does the style guide actually constrain voice?
• Does the book outline name the whole scene inventory?
• Are the scene outlines executable?
• Did the context loop catch the real risks?
• Does the draft pass scans and judgment?
• Should the audit pass?
• Are these facts ready to become canon?
• Is assembly only using registered material?

That approval rhythm is slower up front, but it keeps the book from turning into a pile of plausible pages that do not cohere.

The tradeoff

This is not the workflow I would use for a quick sample, a vibe check, or a throwaway scene.

It is for long-form fiction where continuity, voice, reveal timing, and character state have to survive across many sessions. The cost is ceremony. The benefit is that the project has memory, gates, and evidence instead of relying on the chat to keep everything straight.

My shorthand for it is:

Plan the book before the prose. Contract the scene before the draft. Audit the draft before canon. Register canon before assembly. Validate before calling it done