Writing Novels with AI: A Layered Generation Pipeline to Eliminate the "Machine Flavor"

1. Diagnose First: Four Classic Symptoms of the “Machine Flavor”

When LLMs assist fiction writing, what readers spot first is usually not plot holes but “voice.” The symptoms fall into four categories:

1. Dialogue as tidy as meeting minutes. One character lists points, another confirms them one by one, a third summarizes. Each sentence looks “useful” in isolation, but together they read like a stand-up meeting. The extreme version: characters at an accident scene neither call for help nor take cover—they stand in place delivering a situation report. All the plot information arrives; all the drama is gone.
2. Abrupt emotional turns. Calm in one sentence, an outburst in the next, with no buildup, hesitation, or dissonance in between. It reads rough.
3. Templated scene description. Different combinations of light, wind, dust, and heartbeat that would fit any other scene just as well. That means the description isn’t serving the current narrative—it’s just completing the task of “a description goes here.”
4. Homogenized character voices. You gave five characters different backgrounds, personalities, and histories, but cover the names and it sounds like one person speaking in turn—as if they had all attended the same onboarding training. Who observes, who handles the technical details, who treats the wounded: the division of labor is clear, the personalities are absent.

A key judgment call: if you have already added plenty of rules (don’t chop sentences into fragments, don’t sprinkle “he said” after every line, don’t keep confirming the same information), the local symptoms do improve, but the draft keeps getting stuck in roughly the same places—the problem is not at the wording layer but at the structural layer of the generation process. What needs to change is not the adjectives; it’s the architecture.

2. Root Causes: Where the Machine Flavor Comes From

1. The nature of probabilistic continuation. A model’s objective is to “plausibly continue what came before,” so high-frequency, complete, low-risk phrasing wins by default. “Deliver the information clearly” is a goal that can be reliably verified; “perform the character” has no single correct answer. The model instinctively chooses the former.
2. Goal overload in a single generation. One pass is asked to advance the plot, convey worldbuilding, shape characters, and control style all at once. Once attention is spread thin, the model prioritizes the item that is easiest to validate—informational correctness. Character voice becomes the first metric sacrificed.
3. Register contamination from context. If the prompts and surrounding context are all expository language—requirements, rules, checklists—the continuation naturally carries that “task tone” forward.
4. Character profiles that never reach the voice level. Character cards store nouns—background, occupation, personality—not speech patterns. The model knows “he’s a veteran soldier” but not “he drops subjects and loves rhetorical questions,” so it cannot produce differentiation.

Conclusion: keep piling rules onto single-shot generation and returns diminish. “Organizing the dialogue” and “drafting the prose” need to happen as separate steps.

3. The Solution: Split “Writing a Chapter” into a Three-Layer Pipeline

Settings & character cards
   │
   ▼
[Planning layer] High-tier model → Script (scene goal / character intents / line points / key actions)
   │        ↑ Human-checkable and editable; the cheapest point of correction
   ▼
[Generation layer] Cost-effective model → Expand the script into prose
   │
   ▼
[Revision layer] Independent session / a model better at dialogue → Dialogue-specific revision → Merge back into the prose

3.1 Planning Layer: Script First, Prose Later

The script layer is the highest-return step in the whole pipeline. Have a model that is good at organizing logic (or write it yourself) produce a “script” first: what this scene must accomplish, what each character wants at this moment, the key points of important lines, and who performs which key action. It pays off in three ways:

• A verifiable intermediate representation. A script is only a few hundred words. One quick scan reveals “this dialogue has no conflict” or “this character has no goal right now”—far cheaper to fix than after the full draft is done.
• A single goal per stage. The generation layer receives the script and does exactly one thing: expand the points into prose. No more multitasking.
• An anchor for revision. When dialogue is revised later, you can check each line against “what this character wants right now” to see whether it drifted.

The script layer works well as structured text, which models parse reliably:

scene: After the military train is ambushed, the carriage tilts; five people fight to survive
beats:
  - actor: Escort veteran
    intent: Save lives first, assign blame later
    lines_hint: Short sentences, imperative, drops subjects
    key_action: Grabs the stretcher before it slides away
  - actor: Unit doctor
    intent: Confirm injuries, opposes taking risks
    lines_hint: Precise terminology, urgent tone, sentences often cut off by gunfire
    key_action: Straps the wounded man to the seat frame with a luggage belt

Note that lines_hint describes “how to speak,” not “what to say”—this is the key to character differentiation later.

3.2 Generation Layer: A Cost-Effective Model for Volume

Prose is the biggest token consumer; it neither needs nor deserves to run entirely on the most expensive, tightest-quota model. A cost-effective model expanding the script is more than enough: the plot skeleton and character intents are already locked by the script layer, so its only remaining job is stylistic rendering, and the space for error shrinks dramatically.

3.3 Revision Layer: Dialogue-Specific Treatment

Pull the clearly problematic dialogue passages out of the draft and hand them to an independent session—ideally a different model that is better at organizing dialogue—for dialogue revision, then merge the results back into the prose.

Why it must be independent:

• Escape path dependence. Models have a strong preference for their own output. Same-model self-revision often changes only a few words while the entire speech pattern stays frozen: it read like meeting minutes before, and it still reads like meeting minutes afterward, minus a few repeated words. Switch models, and the “looseness” of the conversation often changes immediately.
• Context isolation. A fresh session isn’t dragged along by tens of thousands of words of narrative context, and it makes it easy to distill a reusable revision prompt that you can apply to every chapter.

4. How to Revise Dialogue: Rules and Acceptance Criteria

4.1 Revision Rules (Ready to Drop into a Prompt)

1. Don’t chop sentences into fragments, and avoid wedging a “he said/she said” after every two or three words.
2. Don’t confirm the same information back and forth; if one exchange can make it clear, don’t stretch it into three.
3. Characters should respond to the other person’s attitude, not just the content: if someone gets yelled at, the reply should carry fear, resistance, or impatience—not a restatement of what was just said.
4. Allow interruptions, non-answers, and half-finished sentences; let actions and context complete what was left unsaid.
5. Lines serve the characters first; cut information wherever possible. Worldbuilding can be distributed into actions and observations instead of being crammed into dialogue.

4.2 Three Acceptance Tests

• Cover-the-names test: Hide every character name. Can you still tell who is speaking from speech patterns alone? If not, the language fingerprint hasn’t been established.
• Read-aloud test: Read it out loud. Wherever it stumbles is where it needs fixing.
• Deletion test: Remove the dialogue entirely. Does the plot suffer? “Information-broadcast dialogue” that the story barely misses is the top priority for a rewrite.

4.3 A Counterintuitive Parameter Observation

On some revision tasks, lowering sampling randomness actually works better. The ornate rhetoric and rich rhythms that high temperature produces are themselves another kind of formulaic writing; low-temperature revision strips redundancy and flattens the embellishment, and the text moves closer to natural human speech. This varies by model and task—compare a few sample passages before locking in a strategy, and don’t treat it as a universal rule.

5. Character Differentiation: From Character Cards to “Language Fingerprints”

A character card answers “who is he”; a language fingerprint answers “how does he talk.” Maintain a voice profile for every character:

• Sentence length and structure: A military reporter builds up with long sentences; a dockworker fires off short ones with the subject dropped.
• Catchphrases and forbidden words: The filler words this person uses constantly—and, just as important, “the words this person would never say.” The latter often defines a character better than the former.
• Different names for the same thing: The same wounded man is “bed three” to the doctor, “that kid” to the veteran, and “Squad leader, look!” from the rookie.
• Emotional expression paths: One person says outright that they’re scared; another starts cursing; another starts over-explaining details.

Write the language fingerprints into the lines_hint field of the script layer so they take effect in both the generation and revision layers. The same line—“the carriage is about to slide”—should come out three completely different ways from three characters. That is the real source of “recognizable even with the names covered.”

6. Cost and Efficiency: Spend the Expensive Models Where They Count

1. Quota is an engineering reality. If you call models through a public cloud LLM service (for example, Baidu AI Cloud), cost usually scales with token usage, so “which task gets which model” directly becomes your cost structure: the high-tier model handles planning and final review, the cost-effective model handles prose volume, and an independent session handles dialogue revision. Each in its place.
2. Rework is the biggest hidden cost. Once layered, most rework gets intercepted at the cheap, upfront script layer. In one test, the time to produce a finished chapter (including multi-round interactive revision) dropped from over thirty minutes to about twelve; even counting the time to write the script, the net saving was roughly ten minutes. The sample is small, but the trend is clear: one low-cost extra step buys a sharp reduction in the expensive ones.
3. Put the planning model up front, not in the post-mortem. Rather than letting your strongest model point out “this passage doesn’t feel natural” after the draft exists—then sending the original model off to blindly guess how to fix it—let it resolve structural problems inside the script before any prose is written. Review capability belongs where errors are cheapest.

7. Implementation Checklist

Everything above, compressed into an actionable list:

• Symptom self-check: Dialogue reads like a report? Names covered, voices indistinguishable? Deleting the dialogue costs the plot nothing? If any of these hit, stop stacking prompts and start restructuring.
• Build the pipeline: Script layer (structured points) → Generation layer (expand into prose) → Revision layer (independent session fixes dialogue).
• Revision rules: No fragment sentences, fewer “he said” tags, no repeated confirmation, respond to attitude, allow incompleteness.
• Voice profiles: One language fingerprint per character, written into the script layer’s line-hint field.
• Three acceptance tests: Cover-the-names, read-aloud, deletion—all three, no exceptions.
• Cost allocation: The expensive model owns planning and final review; the cost-effective model owns volume. Keep revision in an independent session and accumulate reusable prompts.

Closing Thoughts

The “machine flavor” is not, at heart, a wording problem—it’s a process problem. The more goals a single generation carries, the more easily character voice gets sacrificed. Split planning, expansion, and revision into three layers that each do their own job, and let every model do what it does best: the dialogue becomes natural, and efficiency actually goes up. When writing stops being the loop of “generate—revise—guess again” and becomes the pipeline of “script—prose—revision,” AI finally stops being a typist who gives itself away and becomes a writing team with a clear division of labor.