AIGC Text Detection: How AI Content Detectors Work and How to Improve AI-Assisted Writing

1. Problem Background: From Chasing Detection Scores to Understanding Detection Mechanisms

Recently, claims such as “reduce AI rate from 92% to 5%” have spread widely among content creators, students, and knowledge workers. These messages focus almost entirely on the score itself, while ignoring whether the text is more reliable, whether its arguments are better supported, and whether its facts can be verified. From a technical perspective, the more worthwhile questions are not how to make a score checker “fail to detect” AI, but three basic questions: why AI-generated text is easy to identify, which features detection judgments rely on, and how content quality can be improved at the source.

1.1 What the “AI Rate” Really Means

The “AI rate” is a probabilistic judgment produced by content detection services. It usually indicates “the likelihood that the text was generated by AI.” Different platforms use different names and scales. It is neither a determination of authorship nor an evaluation of content quality. The same passage may receive very different conclusions from different tools, mainly for three reasons:

• Heterogeneous models: Detection models are trained on different corpora, select different features, and use different thresholds.
• Input sensitivity: Chunking methods, text length, language, and writing style can affect the output.
• Avoidability: Once detection features become public, targeted rewriting can significantly lower the score, so scores drift over time.

Therefore, treating the “AI rate” as the only optimization target is fragile from an engineering perspective. A more robust goal is to make text fact-based, traceable to sources, varied in expression, and reflective of genuine author contribution.

2. Technical Principles of AIGC Text Detection

2.1 Three Core Statistical Features

1) Low perplexity. Language models predict the next word token by token based on probability. Perplexity measures how “surprising” a text is to the model. Large models tend to choose high-probability words and conventional collocations. As a result, generated text often reads smoothly, but every word is “expected.” Perplexity can be roughly estimated as follows:

import math
import torch
@torch.no_grad()
def perplexity(model, tokenizer, text: str) -> float:
    """Perplexity = exp(-1/N * sum log P(token_i)); lower values indicate more predictable text."""
    ids = tokenizer(text, return_tensors="pt").input_ids
    logits = model(input_ids=ids).logits[:, :-1, :]   # Predict the next token at each position
    targets = ids[:, 1:]
    loss = torch.nn.functional.cross_entropy(
        logits.reshape(-1, logits.size(-1)),
        targets.reshape(-1),
        reduction="mean",
    )
    return math.exp(loss.item())

Note that the GPT-2-style perplexity metric commonly used in public research is not the same as the algorithm used by a specific detector. The result above can only serve as a relative reference and should not be used to infer the judgment of any detection platform.

2) Insufficient burstiness. Human writing shows obvious variation in sentence length. Short and long sentences alternate, and parenthetical remarks occasionally appear. Machine-generated sentences tend to be more uniform. In word choice, models over-prefer high-frequency transition phrases such as “not only… but also…”, “with the continuous development of…”, and “in conclusion.” Paragraph organization is also highly templated.

3) Structural symmetry. Typical large-model output uses a “general–specific–general” framework. Each paragraph revolves around a subpoint, paragraphs are similar in length, and subpoints are listed in parallel using “first, second, third” or “firstly, secondly, finally.” This predictable structure aligns closely with the pattern matching that detectors are good at.

2.2 Why Detection Results Should Not Be Overly Trusted

Detection is fundamentally statistical inference. Both false positives and false negatives exist. The following types of text are especially likely to be misjudged:

• English text written by non-native authors. It may use cautious wording and regular sentence patterns, making its statistical features highly similar to model output.
• Highly formulaic texts such as legal clauses, technical standards, and manuals.
• Paragraphs that are too short to provide sufficient statistical samples.
• Human-written text after multiple rounds of editing that has erased personal style.

Therefore, detection results are best treated as warning signals, not final conclusions. When an unusual signal appears, the content itself should be checked first, rather than blindly rewriting the wording.

3. Four Zero-Cost Manual Rewriting Techniques

Using a general-purpose large language model as a writing assistant is feasible. The key is that the author performs substantial processing after receiving the assistance. The following four methods do not require paid tools, but each requires the author to contribute real thinking.

Technique 1: Information Backfilling—Replace “Correct but Empty” Statements with Unique Content

A common weakness of AI-generated content is that every statement may be correct, but few statements can be traced to a specific source. When rewriting, answer three questions first: What is the basis? What is the scope? What are the exceptions? Specific practices include:

• Add details from the author’s own experience, such as specific scenarios, real dates, actual problems encountered, and how they were handled at the time.
• Attach sources and dates to quantitative conclusions, and verify each one after rewriting to prevent “good-looking but untrue” data.
• Clarify discussion boundaries and applicable conditions, and acknowledge limitations rather than presenting universal conclusions.

From a detection perspective, this kind of content contains many low-frequency words, proper nouns, and unconventional collocations, which naturally raises perplexity. More importantly, it genuinely increases information value.

Technique 2: Rhythm Reconstruction—Restore Natural Variation in Sentence Length

First, mark the three longest and three shortest sentences in the article. Then break up mechanically uniform paragraphs and rearrange them: long sentences should support complete arguments, short sentences should emphasize conclusions or transitions, and rhetorical questions, parenthetical phrases, and dashes can be used when necessary. The following script can be used for a quick check:

import re
import statistics
def split_sentences(text: str) -> list[str]:
    parts = re.split(r'(?<=[.!?;])', text)
    return [part.strip() for part in parts if part.strip()]
def rhythm_report(text: str) -> dict:
    sentences = split_sentences(text)
    lengths = [len(s) for s in sentences]
    if len(lengths) < 2:
        return {"sentence_count": len(lengths)}
    cv = statistics.pstdev(lengths) / statistics.mean(lengths)  # Coefficient of variation
    prefix_ratio = sum(
        1 for s in sentences
        if re.match(r'^(First|Second|Again|Finally|Moreover|Additionally|In conclusion|Overall)', s)
    ) / len(lengths)
    return {
        "sentence_count": len(lengths),
        "average_sentence_length": round(statistics.mean(lengths), 1),
        "coefficient_of_variation": round(cv, 2),  # Reference: below 0.3 indicates overly uniform rhythm
        "template_prefix_ratio": round(prefix_ratio, 2),
    }

A persistently low coefficient of variation and a high proportion of templated connectives usually indicate that the text was generated once without further processing. When adjusting, readability must also be considered: excessively stacking short sentences can also damage writing quality.

Technique 3: Personalized Expression—Prioritize Accurate Terminology and Remove Empty Connectors

Many rewriting suggestions favor large-scale synonym replacement, such as changing “improve” to “boost” or “important” to “crucial.” This approach is risky because it can distort terminology. For example, replacing terms such as “high availability” or “consistent hashing” with near-synonyms may change their technical meaning. The correct order is:

1. Read the entire article, mark key terms and proper concepts, and set them as non-replaceable.
2. Remove function words and transitional sentences that only connect text but carry no information.
3. Rewrite abstract or vague judgments into specific, verifiable statements.
4. Merge adjacent sentences with repeated meanings.

For example, “In conclusion, this solution has important practical significance” can be rewritten as “This solution uses about half the resource overhead of the original solution on small- and medium-sized clusters, but its behavior needs to be re-evaluated when the number of nodes exceeds a certain scale.” The latter is more specific and also has higher information density.

Technique 4: De-Templated Structure—Break Symmetry and Introduce Real Problems

The templated “point–point–point” structure is the easiest to identify and also the most boring to read. The following adjustments can help:

• Move the most valuable conclusion to the beginning so that the following argument supports it, instead of building up to it with a “general–specific–general” structure.
• Subpoints do not need to have equal length or identical sentence patterns. Important parts can be expanded, while secondary parts can be summarized briefly.
• Introduce counterexamples, failure cases, controversial views, or doubts about one’s own conclusion into the argument chain.
• Replace mechanical enumeration such as “first, second, third” with meaningful subheadings or question-and-answer formats.

Introducing counterexamples requires the author to understand the problem itself, not merely repeat conclusions. This is often the most easily skipped yet most valuable part of AI-assisted writing.

4. Systematic Approach: Integrating Rewriting into the Engineering Workflow

For teams that need to process content in batches, such as technical documentation maintenance and content operations, fixing rewriting requirements as automated checks is more sustainable than manually revising each article one by one.

4.1 Engineering Interpretation of Detection Signals

A single signal can only indicate “worth attention”; it cannot prove “definitely AI-generated.” In practice, it is better to combine multiple indicators into a risk score for ranking and routing only, not as a direct disposal criterion:

from dataclasses import dataclass
@dataclass
class TextSignals:
    perplexity: float | None     # Fill in if estimable; skip if missing
    length_cv: float             # Coefficient of variation of sentence lengths
    template_ratio: float        # Proportion of templated sentence patterns
    unsourced_claims: int        # Number of quantitative claims without cited sources
def risk_score(s: TextSignals) -> float:
    score = 0.0
    if s.perplexity is not None and s.perplexity < 20:
        score += 0.4                      # The threshold should be calibrated on your own corpus
    if s.length_cv < 0.3:
        score += 0.2
    if s.template_ratio > 0.3:
        score += 0.2
    score += min(0.2, 0.05 * s.unsourced_claims)  # Fact-checking dimension
    return round(min(score, 1.0), 2)

The weights are only illustrative. Teams should calibrate them based on the statistical distribution of their own corpus and validate them with human review results. Model versions and thresholds should also be recorded so that detection results can be compared across different time periods.

4.2 Human-in-the-Loop Content Review Pipeline

1. Generation stage: When asking the model to produce a first draft, also request a list of key points and a list of information that needs verification, so that later editing has a clear basis.
2. Automated check stage: Calculate the statistical indicators above and identify templated sentence patterns and unsourced data.
3. Human review stage: Focus on factual accuracy, terminology consistency, and conclusion validity. These three items cannot be replaced by automated indicators.
4. Audit trail stage: Preserve the first draft, revision records, and review conclusions for traceability and continuous improvement.

When implemented on the cloud, the components can be organized using a general architecture:

• Store document files in object storage, organized by project or version.
• Distribute processing tasks asynchronously through a message queue, supporting batch processing and retries.
• Centralize application logs in a logging service so issues can be located by document ID.
• Set monitoring alerts for processing time, failure rate, and human rejection rate.

These are general industry capability categories. For example, Baidu AI Cloud can support this workflow with common cloud services, but the technical choices are not tied to a specific cloud vendor.

5. Risk Warnings and Compliance Boundaries

• Beware the side effects of “one-click AI rate reduction”: Mechanical rewriting often leads to factual drift, terminology distortion, and formatting errors, such as broken formulas, tables, or citation numbers. Claims such as “lower the AI rate from 92% to 5%” also lack reproducible evaluation evidence.
• Beware privacy leakage: Uploading unredacted paper drafts, internal documents, or code to untrusted services may create data leakage risks. Prefer services that explain data deletion and retention policies, and redact information beforehand.
• Maintain integrity boundaries: In education, research, and publishing scenarios, disguising AI-generated content as fully original is academic misconduct. Rewriting techniques cannot replace genuine research and thinking. For enterprises, content compliance may also involve advertising claims and copyright citation requirements, so necessary review procedures should be completed before publication.

6. Conclusion

The “AI rate” is essentially a statistical signal, not a final judgment of textual value. Instead of chasing a constantly changing number, it is better to invest in three things that can accumulate over time: making every statement evidence-based, making every expression varied, and making every conclusion verifiable. When the content itself is solid enough, the expression naturally moves away from templated traces. This is far more reliable than any “one-click rewrite.”