Writing Novels with AI: How to Get Rid of That "Machine Flavor"

Anyone who has written long-form fiction with AI knows the experience: the model can advance the plot and fill the word count, but the finished draft always carries an indescribable “machine flavor.” It shows up as three symptoms—dialogue so tidy no real person would say it, emotional turns stiff enough to jar the reader, and environmental descriptions that forever read like templates. This article starts from the root causes and lays out a practice-tested “four-layer generation pipeline,” with special focus on the most stubborn problem: unnatural dialogue.

1. Where the “Machine Flavor” Comes From: Diagnose First, Then Prescribe

1.1 Three typical symptoms

Symptom 1: Characters speak as if they all attended the same onboarding session. Even when you give five characters distinct backgrounds, personalities, and life experiences, they still talk like one person taking turns giving reports: this one covers observation, that one handles technical matters, another does the healing—divided as cleanly as a shift-handover log. Cover the names and you cannot tell who is speaking.

Symptom 2: Information delivery reads like meeting minutes. The typical pattern: one character reads out two or three pieces of information in sequence, another confirms them one by one, and a third wraps up with a summary. Each line is individually useful; together they form a meeting nobody would want to sit through. Delete a few repeated words, and the meeting is still in session.

Symptom 3: Situational awareness is missing. In crisis scenes, characters do not shout for help or scramble to relay word—they stand at the accident site delivering situation briefings. Machine guns are firing, and they are still exchanging intelligence at a normal volume.

1.2 Three root causes

Viewed through an engineering lens, these problems are not the result of writing too few prompts. They have deeper causes:

• Alignment-induced “politeness.” After instruction tuning and alignment with human preferences, LLM output naturally skews toward complete, structured, watertight expression. Real people do the opposite: they omit words, talk over each other, answer the wrong question, and leave sentences half-finished. The more “well-mannered” the model, the fainter the human touch.
• Task overload in a single generation pass. When one call must simultaneously advance the plot, design dialogue, paint the environment, and control pacing, the goals pull against one another and every dimension settles on a “mean answer”—and the mean is precisely what template feel is.
• Decoding convergence. Models gravitate toward the most common expressions in their training distribution. Left unchecked, different characters and different scenes all drift into the same “standard literary voice.”

The conclusion: rather than piling on rules, restructure the pipeline—split the flow so each call focuses on a single job, and carve out the worst-hit area, dialogue, for separate handling.

2. The Core Solution: A Four-Layer Generation Pipeline

Borrow the layered thinking of software engineering: architecture design first, then interface definition, then implementation, then a dedicated review. Mapped onto novel generation, that gives you this pipeline:

[Planning Layer]        Strongest model, tightest quota
   │  Output: chapter goals, scene list, information release order
   ▼
[Script Layer]          Mid-tier model
   │  Output: dialogue drafts + key action notes (intermediate representation)
   ▼
[Expansion Layer]       Cost-effective model (ample quota)
   │  Input: script + summary of preceding text + style constraints → prose draft
   ▼
[Dialogue Revision Layer]  A conversational model with a more natural ear (independent session)
      Output: final draft with only the dialogue revised

2.1 Planning layer: pacing control goes to the strongest model

How chapters are arranged, when conflicts escalate, and the order in which information is released to the reader—these skeleton-level decisions go to the strongest model. Its quota is the most expensive, so it only handles planning and final review and never touches the prose itself. The pipeline exists precisely to avoid an inefficient loop: waiting until the draft is finished for a strong model to point out “this passage feels unnatural,” then sending the original writer back to guess at the fix all over again.

2.2 Script layer: the pivotal step of the whole approach

The script layer plays the role of an intermediate representation (IR) in a compiler: a model first organizes “who is speaking, what is said, and what is happening at the same time” in script format, then hands it to the expansion model to flesh out. It delivers two direct gains:

• Dialogue quality moves upstream. At the script stage, dialogue is already organized by “speaker + intent + action,” so the expansion model only fills in narrative connective tissue and never gets the chance to flatten conversations into a running account.
• Speed goes up, not down. In practice, adding the script layer cut prose generation time from more than 30 minutes to about 12; even counting the script layer’s own generation cost, the overall flow still saves roughly 10 minutes. The numbers are not precise, but the direction is stable: structured input sharply compresses the expansion model’s degrees of freedom, so output is steadier and rework rarer.

2.3 Expansion layer: prose goes to cost-effective models

Prose is bulky; you cannot spend your most expensive quota on every word. The sensible move is to hand the prose to a model with ample quota and a lower unit price, feeding it the script, a summary of the preceding text, and style constraints (do not chop sentences too finely, use “he said” sparingly, characters should respond to each other’s attitudes). Constraints still matter, but only as a baseline defense—they are no longer expected to “rescue the dialogue.”

2.4 Dialogue revision layer: one separate pass, dialogue only

Early attempts to have the expansion model revise its own output showed limited gains: it sometimes removed repeated explanations and completed broken-off sentences, but the way everyone in the scene spoke stayed exactly the same—the words got wiped clean, yet the meeting was still in session. The more effective approach is to extract the dialogue and hand it to a different model that is better at everyday conversation and has a more natural ear, for a dedicated revision pass in an independent session. Two reasons:

• Conversational models have seen a wider distribution of real spoken language and sit further away from “AI-style polish and tidiness.” In practice, smaller, less “refined” model tiers have sometimes produced livelier dialogue revisions.
• An independent session cuts off “accent contamination” from the original draft’s context, so the revision model is not dragged along by the tone of the preceding prose.

3. Five Concrete Techniques for Dialogue Revision

1. Build a “voice card” for every character. Beyond background and personality, explicitly list: typical sentence length, catchphrases, vocabulary the character avoids, and habitual gestures while speaking. Enter the cards along with the dialogue during revision to force the model “into character.”
2. Break the “read–confirm–summarize” structure. Information does not need to be recited in turns: allow interruptions, talking over each other, and answers to the wrong question; allow someone to mishear and someone to deliberately change the subject. As long as the total amount of key information is conserved, the messier the process, the more human it reads.
3. Respond to attitude before content. When a character picks up a line, the first sentence should answer the other person’s emotion or stance (“Cut it out,” “Calm down first”) rather than directly pushing information forward.
4. Run situational stress tests. Check each scene: when the machine guns open fire, is the character shouting hard enough to be heard over them? When the carriage is about to slide off, is the first reaction a cry for help? Steady, long sentences in a crisis scene are basically a verdict of failure.
5. Control rule density. Once prompt rules pile up into the dozens, the model starts dropping balls. Keep revision instructions to five core rules or fewer, and let voice cards and examples carry the rest.

A revision prompt template you can use directly:

# Role
You are a fiction dialogue revision editor. Revise dialogue only; do not touch narration or plot.
# Input
1. Voice cards for each character
2. The dialogue passages to revise
# Rules
- Delete repeated confirmations: once two speakers have aligned on information, cut it, along with any third-party summary
- Allow interruptions, talking over each other, and off-target answers; no key information may be lost
- In crisis scenes, the first reaction is action and shouting, not reporting
- After finishing, read through with the names hidden: it only passes if you can still tell who is speaking
# Output
Line by line: original → revised → a one-sentence rationale

4. Quotas and Costs: An Engineering Constraint Worth Facing

Beyond quality, the layered approach also solves the resource problem:

• Model routing principle. Reserve the most expensive model for the two points where it matters most: planning and final review. Hand prose and scripts to cost-effective models. Dialogue revision involves little text, so the free trial quotas offered by the platforms are usually enough to cover it. Major LLM service platforms (for example, Baidu AI Cloud’s model services) commonly offer models in multiple tiers along with some free quota, which naturally fits this kind of tiered, task-based scheduling.
• Session isolation. Run dialogue revision in an independent session: it avoids context contamination, makes it easy to evaluate revision quality on its own, and lets you roll back at any time.
• Version management. Keep prompts under version control, and compare each revision with the previous one to avoid “improving” your way backward.

5. Verifying the Results: A Four-Item Checklist

• Masked-name test: cover the speaker names—can you still tell who is talking? If not, it fails.
• Read-aloud test: read the dialogue out loud and mark any sentence that feels awkward, tongue-twisting, or “too tidy” for rewriting.
• Information conservation: the dialogue may get “messy,” but the scene’s key information (who, where, what to do) must not be lost.
• Timing statistics: record the generation time of each layer and confirm the pipeline’s net gain is positive.

6. Summary

The “machine flavor” cannot be cured by stacking prompts; its root lies in the generation architecture. When a single call carries too many goals, the output inevitably drifts toward the mean. Split the flow into planning, script, expansion, and dialogue revision—each layer doing one thing, each model doing what it does best—and dialogue comes noticeably alive, with emotion and scene description loosening up in its wake. In practice, finished-draft time dropped from over 30 minutes to about 12, and quality and cost improved at the same time for the first time. For authors who use AI-assisted writing over the long run, this “layered generation + specialized revision” approach is worth building before any individual writing tip.