How to Get Rid of the “Machine Feel” When Using AI to Write Fiction

When people use large language models to write fiction, the most common complaint is not that the plot makes no sense—it is that the text does not read like something a human wrote. Dialogue comes out as tidy as meeting minutes, emotional turns land like a slap, and environmental description has a distinct template flavor. Worse, these problems usually cannot be fixed by repeatedly editing prompts. You add rule after rule, and the draft still gets stuck in roughly the same place.

This article breaks down the causes of the “machine feel” from an engineering practice perspective and offers a reusable layered collaboration scheme: split planning, dialogue organization, and prose expansion into separate stages, let models with different strengths handle different jobs, and add a targeted dialogue revision round. Under limited quota, this raises both text naturalness and generation efficiency at the same time.

1. The Root of the Problem: A Single Model Takes On Conflicting Tasks

Many people write fiction by having “one model do everything from start to finish”: give it a setting and let it produce the prose directly. This looks convenient, but in practice it compresses several conflicting objectives into a single generation pass:

• Plot advancement requires complete information, clear causality, and controllable pacing;
• Character dialogue requires colloquial language, attitude, subtext, and permission to be incomplete;
• Environmental description requires sensory detail and consistent point of view, while avoiding stock phrases.

When these three objectives are crammed into the same decoding process, the model tends to choose the “safest” expression—complete information, neat structure, neutral wording. The result: the events are explained clearly, but the characters talk like plain boiled chicken breast.

A typical symptom is “turn-based reporting dialogue”: one person recites two or three pieces of information in order, another confirms them one by one, and a third summarizes. Every line has an explainable purpose, yet together they still read like meeting minutes. Delete a few repeated words and the meeting continues.

This shows that the root cause is not at the vocabulary level but at the organizational structure level: the model never first works out who wants what in this conversation, who is avoiding what, and whose attitude is changing—it just starts generating sentences.

2. The Approach: Split Writing into a Layered Pipeline

Since a single model struggles to satisfy conflicting objectives at once, the natural move is task layering. A workable layered structure looks like this:

Layer 1: Planning   — determine scene goals, character motivation, order of information release
Layer 2: Script     — organize dialogue intent and key actions, without chasing literary polish
Layer 3: Prose      — expand the script into full narrative text
Layer 4: Revision   — dedicated revision focused only on dialogue and communication quality

The key point: each layer solves only one class of problem, and different layers are allowed to use different models. The planning layer needs strong reasoning and global consistency, so it suits a more capable model. The prose layer consumes a lot of tokens at high frequency, so it suits a model with ample supply and controllable cost. The revision layer only handles local communication fragments, so it can run in a separate session.

The first direct benefit of this split is speed. In practice, adding a script layer that organizes dialogue and key actions before handing off to the prose model cut prose generation time from over 30 minutes to about 12 minutes—still saving about 10 minutes even after counting the script stage. The reason is that the script layer removes the “think while writing” burden in advance, so the prose model no longer has to repeatedly weigh character intent during generation.

The second benefit is diagnosability. When the text has a problem, you can locate which layer caused it: did the planning layer fail to supply enough motivation, did the script layer fail to arrange attitude shifts, or did the prose layer turn colloquial speech into written language? This is far more efficient than “try tweaking the prompt again.”

3. How to Write the Script Layer: Give Dialogue Intent First

The script layer is not an outline, and it is not the final dialogue. It is an intermediate representation. Its core is to record the intent and attitude behind each line, not the specific wording.

A simplified script entry can look like this:

scene: The carriage is about to slide
characters:
  - name: A
    role: Responsible for observation
    state: Nervous, wants to confirm the situation but dares not shout
  - name: B
    role: Responsible for technical work
    state: Focused, needs to be heard over the noise
beats:
  - actor: A
    intent: Warn B about the rear
    attitude: Urgent, incomplete sentences
  - actor: B
    intent: Respond and ask for repetition
    attitude: Did not catch it, slightly impatient
  - actor: A
    intent: Repeat the key information in the fewest words
    attitude: Almost shouting

With this layer in place, the prose model’s job shifts from “create dialogue” to “turn intent into wording that fits the context”—a much easier task. At the same time, the script layer naturally prevents “turn-based reporting,” because every beat is bound to an attitude and state, leaving no room for the model to turn the conversation into an information-confirmation process.

One practical effect: characters finally know they need to shout to be heard when the machine gun fires, and that they should call for help when the carriage is about to slide—instead of standing at the scene of the accident giving a situation report.

4. Dedicated Dialogue Revision: Run It Separately, Not Mixed into Prose

Even with a script layer, dialogue in the prose can still retain traces of written language. At this point it is worth scheduling a separate dialogue revision round rather than expecting the prose model to get it right in one pass.

Design points for the revision round:

1. Only change communication fragments—do not touch narration or environmental description, to avoid introducing new inconsistencies;
2. Give an explicit negative list: do not chop sentences too finely, do not insert “he said” every two words, do not have characters confirm the same thing back and forth, and make characters respond to each other’s attitudes;
3. Preserve information completeness: colloquial does not mean dropping information—key facts must still be conveyed in the dialogue;
4. Allow imperfection: real conversation has pauses, repetition, and answers that miss the point. The goal of revision is “sounds like a person,” not “more polished.”

In practice, a higher revision level is not always better. In early tests, a lower-intensity revision level performed best—it was farthest from that “strange refinement and neatness.” Some sentences became more complete, and some redundant explanations were removed, which did help. But there were also cases where a few words were changed and the whole way of speaking stayed the same. At that point you need to go back to the script layer and check: if the beats themselves are structured like meeting minutes, no amount of wording changes at the revision layer will save it.

5. The Real Constraints of Cost and Quota

Another benefit of layered collaboration is that quota can be allocated. Prose generation needs relatively ample supply—you cannot hand every word to the most expensive, most quota-constrained model. A more realistic approach:

• The prose layer uses a model with ample supply and controllable cost to carry the bulk of generation;
• The planning layer and key revisions use more capable models, but only process small fragments;
• The script layer outputs structured short text with low token consumption, making it suitable for running on a strong model.

This ensures quality at critical stages without letting the quota of high-capability models be overwhelmed by the flood of prose. The earlier example of “prose dropping from 30 minutes to 12 minutes” also shows that moving organizational work forward into lightweight stages actually reduces overall compute and time overhead.

6. A Reusable Collaboration Flow

Putting the above experience into a flow, it looks roughly like this:

1. Planning: strong model outputs scene goals, character motivation, order of information release
2. Script: strong or mid-tier model outputs beats (intent + attitude + key actions)
3. Prose: cost-controllable model expands from the script, forbidden from inventing dialogue structure
4. Revision: a separate session handles dialogue specifically, checking item by item against the negative list
5. Regression: spot-check "does it read like the same person with names hidden"—if yes, return to step 2

Step 5 is a practical check: give five characters different backgrounds, personalities, and experiences, and if they all sound like they attended the same onboarding session, the script layer has not differentiated their states. Blind testing with names hidden is the lowest-cost consistency check.

7. Conclusion

The “machine feel” cannot be eliminated by piling up prompts. It is essentially a projection of task conflict onto the surface of the text. Only by splitting planning, dialogue organization, prose expansion, and dialogue revision into separate stages, letting different models take on the parts they are good at, and using the script layer as an intermediate representation to lock in character intent and attitude, can you achieve both naturalness and efficiency under limited quota. This method does not depend on the capability ceiling of any particular model—it depends on process design. For everyday writing tasks, that is far more realistic than waiting for a model that “writes everything well.”