AI-Assisted Long-Form Fiction Writing: Reducing Entropy and AIGC Traces in Practice

1. Introduction: The “second half” problem in long-form content

After large language models became widely available, “generating a paragraph with AI” is no longer a technical barrier. For professional web fiction authors, content studios, and cross-media teams, the harder engineering problem appears in the second half of content production.

How do we make long text feel human-written? How do we keep a story of several hundred thousand words from contradicting its own setting? How do we avoid the early draft being penalized by platform quality models for being low-value and template-like?

Technically, many of these issues can be traced to one core metric: perplexity.

Language models are trained with maximum-likelihood objectives, so they naturally prefer high-probability, predictable expressions. In massive training corpora, connective structures such as “as if,” “not only … but also …,” and “in summary” appear repeatedly, and they are therefore reused frequently during generation. As a result, many paragraphs share the same traits:

• Highly symmetrical sentence patterns;
• Overly safe and conventional word choices;
• Little variation in rhythm;
• Slow progression of information.

These are exactly the signals that quality and originality detection models often associate with “low-quality AI-generated text.”

A terminology clarification is needed. In industry discussions, terms such as “entropy reduction” and “lowering the AI rate” do not literally mean reducing entropy. Technically, they usually refer to increasing the conditional entropy of the text, making the output statistically harder to predict. To stay consistent with common usage, this article still uses the phrase “entropy reduction,” but the real goal is to increase perplexity and burstiness.

This article does not focus on any single tool. Instead, it breaks the problem down from statistical principles, discusses general methods for both generation and post-processing, presents a practical long-form writing pipeline, and finally clarifies the compliance boundaries.

2. Principles: Where the “machine flavor” comes from

2.1 Perplexity: A ruler for text predictability

Given a text consisting of tokens w₁, w₂, …, w_N, a language model produces a conditional probability for each next token: P(wᵢ | w₁, …, wᵢ₋₁). Perplexity is defined as:

PPL(T) = exp( −(1/N) · Σ log P(wᵢ | w₁, …, wᵢ₋₁) )

Intuitively:

• PPL = 1: The model predicts every token correctly. The text is fully predictable. This is the ideal form of template-like writing.
• High PPL: The text contains many long-tail words and unconventional collocations, making it harder to predict. This is common in spoken language, dialects, and experimental literature.

Machine-generated text usually falls into a high-probability region of the distribution, so its perplexity is often clearly lower than natural writing by the same author. This is why many quality models treat low perplexity as a signal of “machine flavor.”

2.2 Burstiness and lexical richness: The “human feel” in rhythm

Overall perplexity alone is not enough. Two additional dimensions matter:

• Burstiness: Variation in perplexity across different parts of the same text. A human author may write dense short sentences and high-perplexity phrasing during action scenes, then shift to slower, calmer long sentences during introspective passages. Model-generated text often has a smoother perplexity curve.
• Lexical richness: Metrics such as type-token ratio and repeated n-gram ratios. AI-generated text often repeatedly uses hedging adverbs and metaphorical fillers such as “as if,” “seemingly,” and “slowly,” creating local high-frequency patterns.

2.3 Typical language features of AI-style writing

Feature category	Typical manifestation	Why it happens
Template-like connectors	“as if,” “not only … but also …,” “in summary,” “it is worth noting”	High-frequency written connectors in training corpora
Symmetrical parallelism	Three-part short clauses, neat antithesis	Repeated sampling of high-probability collocations
Smooth transitions	Fixed bridging phrases between paragraphs	Maximum-likelihood solutions for contextual coherence
Redundant modifiers	“slowly,” “gently,” “faintly”	Safe, generic collocations have high probability
Low information density	Excessive introspection and summarizing	Lack of concrete actions and scene details
Overly regular punctuation	Long sentences, dense commas, few dashes or ellipses	Preference for formal written norms

3. Detection: How quality models look at text

Understanding detection logic helps explain what kinds of text are likely to be judged as low quality. It is not a guide for bypassing review. Current mainstream AI-text detection approaches can be divided into four categories.

1. Zero-shot statistical detection.
This directly uses perplexity thresholds, or compares the perplexity ratio of text under a general model and a fine-tuned model. It is simple and requires no training, but it is easily weakened when the text has been rewritten.

2. Perturbation-based detection.
The core idea is that machine-generated text often has a different “probability curvature” from human text when subjected to small edits such as synonym replacement. A detector can apply small perturbations and observe how the probability pattern changes.

3. Supervised classifiers.
Discriminative models are trained on human-written and machine-generated samples. Inputs can be raw text or statistical features such as word frequency, syntax, and style. These methods can be accurate within the training distribution, but they may misjudge specialized genres such as xianxia or infinite-flow fiction.

4. Provenance and source labeling.
Some generation services embed statistical watermarks in outputs. There are also industry standards for content provenance and authenticity labeling. Platforms may also combine signals such as account history, publishing frequency, and repeated content ratio.

One easily overlooked fact is the high false-positive rate. Multiple public studies show that some detection tools misclassify a substantial portion of human writing as AI-generated, and non-native writers are especially likely to be affected. Therefore:

• Detection scores are reference indicators, not quality verdicts.
• Treating “fooling the detector” as the only goal often hurts readability.
• The more effective approach is to improve naturalness and information density at the source.

4. Generation-side practice: Making the model write less like a model

4.1 Decoding strategy is the first gate for entropy reduction

When a model generates text, it selects one token at each step. Common strategies include:

• Greedy decoding: Always choose the highest-probability token. The output is deterministic and conservative, with the lowest perplexity and the strongest “AI flavor.”
• Temperature sampling: Scale logits by a temperature coefficient T before applying softmax. When T > 1, the distribution becomes flatter; when T < 1, it becomes sharper. The closer the temperature is to 1, the more diverse the output tends to be.
• Top-p sampling: Sample only from the smallest set of tokens whose cumulative probability reaches p. This balances diversity and coherence.
• Top-k sampling: Sample only from the k highest-probability tokens.
• Repetition-penalty parameters: Penalize already-used tokens to suppress literal repetition and verbal tics.
• Deterministic decoding methods such as contrastive search: Suitable for setting organization, summarization, and other tasks requiring stable reproduction, but less suitable for prose that needs rhythmic variation.

Example configuration (field names may vary by service):

{
  "temperature": 0.95,
  "top_p": 0.92,
  "frequency_penalty": 0.3,
  "presence_penalty": 0.2,
  "max_tokens": 1200
}

One caveat is that penalty parameters mainly control literal repetition. They do little to fix sentence-pattern templates. Raising temperature indiscriminately is also harmful, because it can cause logical breaks and setting drift. A more reliable practice is: generate multiple candidates with relatively high temperature, then select the best version using rules. For example, prefer versions with high sentence-length variance and few repeated n-grams from the preceding text.

4.2 Prompt engineering: Give the model a style constraint

Parameters affect sampling randomness, but prompts are what truly shape style. A web-fiction-oriented prompt template can include the following elements:

[Identity] You are the author of [Work Name], skilled at writing combat scenes with a cold, restrained, descriptive style.
[Chapter outline] ...
[Required prior context] ...
[Canon that must be preserved] ...
[Style constraints]
  1. Alternate long and short sentences. Do not use the same sentence pattern more than three times in a row.
  2. Forbidden words: as if, as though, could not help but, slowly, faintly, in summary, it is worth noting, not only ... but also ...
  3. Each paragraph must contain at least one concrete action or sensory detail.
  4. Dialogue should account for at least 30%. Dialogue must match the character's identity and verbal habits.
[Output requirements] Output only the chapter body. Do not write a chapter summary. Do not explain the writing plan.

Two practical lessons:

• Show first, instruct later. Providing two or three sample paragraphs in the target style is usually much more effective than simply listing adjectives.
• Turn the “forbidden list” into an engineering configuration. A program can automatically assemble it into the prompt, reducing the risk of forgetting items during manual writing.

4.3 Human-AI collaboration: Let the author write the hook, then let the model expand

What models are worst at is often exactly what best demonstrates an author’s style: opening hooks, a character’s unique speech habits, and chapter-ending suspense. A division of labor validated in practice is:

1. The author manually writes the first three to five sentences and the ending suspense.
2. The model expands the middle sections under those constraints.
3. The author revises key dialogue and highlight scenes line by line.

This approach uses the model’s efficiency for scene expansion while preserving the author’s stylistic fingerprint. Statistically, human anchors also naturally increase burstiness.

4.4 Change the task framing: From “generation” to “continuation” and “rewriting”

The same passage produces noticeably different output depending on the instruction. Starting with “Please create according to the following outline” is not the same as starting with “Please continue writing.” Continuation tasks often make the model inherit the preceding text’s sentence length and word distribution more strongly. Similarly, treating the model as a “polisher” rather than a “creator,” and asking it to rewrite an author-written draft, usually produces output closer to the author’s original style.

5. Post-processing: General rules for text reconstruction

After generation, another reconstruction pass is still needed. The following rules do not depend on any specific tool. They can be implemented in code or requested from the model through prompts.

(1) Break up sentence patterns.
Convert progressive structures such as “not only … but also …” into short sentences plus actions. Split long complex sentences into two or three shorter ones, and occasionally insert one or two three-to-five-word sentences to create pauses.

(2) Remove unnecessary summarization.
Delete paragraph endings such as “in summary” or “needless to say,” as well as vague grand statements such as “this battle was destined to go down in history.” Replace summary conclusions with concrete consequences.

(3) Clean templates.
Build a list of forbidden words and sentence patterns. Scan the draft automatically, flag matches, and have the author replace them one by one.

(4) Increase information density.
Each paragraph should advance at least one plot point or add a concrete sensory detail, such as light, temperature, sound, or smell.

(5) Add punctuation rhythm.
Use dashes for interruptions, ellipses for trailing endings, and single-sentence paragraphs where appropriate to imitate the breathing rhythm of human writing.

Example: before and after rewriting

Before (typical AI style):

Night fell like a vast black curtain. Not only did he show no fear, but he also displayed astonishing courage. This battle was destined to go down in history. In short, he proved his strength through his actions.

After:

Darkness came.

He did not retreat. The blade pointed downward. Blood dripped from the edge onto the bluestone, one drop at a time. Seven people stood opposite him. No one moved first. The third man swallowed. In the darkness, the sound was especially loud.

Example of constrained rewriting prompt:

Rewrite the following passage while obeying these rules:
- Preserve all plot information and character actions. Do not add or remove key facts.
- Remove template expressions such as "as if," "not only ... but also ...," and "in summary."
- Break long sentences and add short sentences. Keep each sentence under 35 words.
- Do not add plot events that are not present in the original.
- Output the rewritten text and list the changes.

If a model is used for rewriting, the following constraints are recommended:

• Keep the temperature between 0.7 and 0.9 to reduce the chance of introducing new hallucinations during rewriting.
• Rewrite paragraph by paragraph and keep the original text for comparison, making manual review easier.
• Put proper nouns, character names, and setting terms on a protected list and prohibit replacing them.

6. Long-form consistency: Use retrieval-augmented generation against “setting drift”

“Entropy reduction” addresses whether the text feels human-written. Long serialized fiction also needs to address whether it is still the same story. In a million-word work, character sheets, timelines, and foreshadowing relationships cannot all fit into the context window. A common approach is retrieval-augmented generation, or RAG.

1. Structured modeling: Convert character sheets, faction relationships, geography, and timelines into structured entries. Each entry should include tags, volume membership, and an update timestamp.
2. Chunking and indexing: Generate vector representations for each entry and store them in a vector database along with metadata.
3. Dynamic retrieval: Before generating a new chapter, use the chapter outline and the end of the previous chapter as queries. Retrieve relevant entries and inject them into the prompt.
4. Unified rewriting: After every few chapters, update character states and foreshadowing states to prevent contradictions.

Example pseudocode (interfaces are illustrative):

def build_chapter_prompt(outline, prev_tail, store):
    # Use the outline and previous chapter ending as a hybrid query to retrieve relevant settings.
    hits = store.search(query=outline + prev_tail, top_k=8,
                        filters={"status": "active"})
    setting_block = "\n".join(f"[{h.type}] {h.text}" for h in hits)
    return f"""[Relevant settings]
{setting_block}
[End of previous chapter]
{prev_tail}
[Current chapter outline]
{outline}
Continue writing the chapter body based on the settings above. Do not introduce unregistered characters or place names."""

In engineering practice, there is no need to build the entire stack from scratch. General-purpose cloud capabilities such as managed model inference, vector databases, object storage, logging and monitoring, and message queues can be combined into a creation and review pipeline.

7. Quality evaluation: Use metrics instead of intuition

Entropy-reduction work must be measurable. Otherwise, it is impossible to tell whether an adjustment is an improvement or a regression. It is useful to create a chapter health-check table that calculates metrics automatically before each chapter is accepted.

import math, re, statistics
TEMPLATE_PATTERNS = [
    "as if", "as though", "could not help but",
    "in summary", "needless to say", "it is worth noting"
]
def text_stats(logprobs, text):
    """logprobs: token-level log probabilities corresponding to the text (illustrative)."""
    n = len(logprobs)
    ppl = math.exp(-sum(logprobs) / n) if n else float("inf")
    # Segment with a fixed window and calculate perplexity fluctuation (burstiness).
    seg_ppl, w = [], 200
    for i in range(0, n, w):
        part = logprobs[i:i + w]
        if part:
            seg_ppl.append(math.exp(-sum(part) / len(part)))
    burst = statistics.pstdev(seg_ppl) / statistics.mean(seg_ppl) \
        if len(seg_ppl) > 1 else 0.0
    # Lexical richness and template hits.
    words = re.findall(r"[A-Za-z']+", text.lower())
    ttr = len(set(words)) / len(words) if words else 0.0
    hits = {p: text.lower().count(p) for p in TEMPLATE_PATTERNS if p in text.lower()}
    return {
        "ppl": round(ppl, 2),
        "burstiness": round(burst, 2),
        "ttr": round(ttr, 3),
        "template_hits": hits
    }

How to interpret and use these metrics:

• Perplexity: Comparisons are meaningful only under the same model and the same evaluation method. Absolute values are not comparable across models. More useful is the difference from the author’s own natural-writing samples.
• Burstiness: A higher value means more rhythmic variation, but excessively high values may indicate unstable paragraph quality.
• Type-token ratio: This metric is strongly affected by text length. For long texts, calculate it in fixed windows.
• Template hits: Ideally, this should be reduced to zero. It is the easiest metric to maintain and often has the most direct payoff.

It is best to first collect the author’s historical chapters as a baseline, then set thresholds accordingly, rather than adjusting parameters by feel.

8. Recommended workflow: A reusable long-form creation pipeline

Combining the methods above yields a five-stage pipeline:

Stage	Core actions	Key outputs
① Setting modeling	Structure characters, factions, and timelines	Setting entries and tags
② Outline decomposition	Volume outline → chapter outline → scene cards	Per-chapter goals, conflicts, and foreshadowing lists
③ Human-AI co-writing	Author writes hooks; model expands under setting constraints	Chapter draft
④ Text reconstruction	Break up sentences, remove templates, add details, adjust rhythm	Polished draft
⑤ QA and ingestion	Statistical health check + human final review + state write-back	Publishable chapter and updated setting state

The state write-back in step ⑤ is the most easily overlooked. After a chapter is published, character locations, injuries, possessions, and the status of planted or recovered foreshadowing should be written back into the setting database. Otherwise, the next retrieval round cannot obtain the latest state. Without this step, even a well-designed retrieval mechanism will gradually experience “memory confusion.”

9. Common pitfalls and risk boundaries

• Believing in “trace-removal tools.”
  No post-processing tool can create plot or characters out of nothing. If only sentence patterns are changed without changing content, the result is often just “weirder-looking AI text.” The upper limit of naturalness is determined by creative quality.

• Overdoing entropy reduction.
  Setting the temperature to an extreme, or forcibly inserting dialects and typos, can damage readability and may affect normal recommendation performance on publishing platforms.

• Ignoring false positives.
  Strongly stylized literary fiction and experimental writing may also be misclassified. Do not use a detection score to override an author’s own stylistic judgment.

• Compliance red lines.
  Many content platforms have labeling or disclosure requirements for AI-generated content, and bulk production of template-like content is commonly targeted. Whether to use AI, and how to use it, should follow the latest rules of the target platform. Using adversarial techniques to evade detection is not a legitimate way to bypass platform content rules, and it may create account penalties or legal risks.

• Copyright and data.
  Style-reference samples must come from lawful sources. Do not feed entire copyrighted works into the generation pipeline, and perform necessary originality checks on model output.

10. Conclusion

For long-form fiction, the value of AIGC is to free authors from repetitive labor, not to mass-produce template texts that merely look like novels.

So-called entropy reduction and AI-flavor removal essentially involve two separate tasks:

• On the generation side, use sampling parameters, prompt constraints, and human-AI division of labor to increase statistical diversity.
• On the post-processing side, improve the reading experience through sentence reconstruction and higher information density.

Combined with retrieval-augmented generation for long-form consistency and statistical metrics for quality closure, AI can truly become a “copilot” for long-form fiction. Metrics can optimize style, but what ultimately determines the success of a work is still the story itself.