Qwen3-4B Without AI Clichés: How an Engineer Pulled It Off

⏱️ Reading time: 14 min

An engineer trained Qwen3-4B to stop writing like an AI: the AI slop score dropped from 121 to 12.5 per 1,000 words, and rhetorical em dashes went from 20.5 per 1,000 words to zero, according to the author’s own writeup.

📑 En este artículo

1. TL;DR
2. What are AI writing clichés?
3. Why they show up: RLHF’s bias toward human approval
4. How the targeted fine-tuning works to remove them
   1. The writing-tic detector: how the score is measured
5. Practical examples: before and after
6. Getting started: running Qwen3-4B-deslop on Ollama
7. Real use cases
8. Common mistakes and best practices
9. Comparison: three ways to remove a model’s mannerisms
10. Going deeper: the hidden direction inside the weights
11. Frequently Asked Questions
    1. What does it mean for a model to have AI writing clichés?
    2. How is Qwen3-4B-deslop trained to avoid these tics?
    3. Does it perform the same as the original model on factual questions?
    4. Is it free to run Qwen3-4B-deslop on Ollama?
    5. Does this kind of fine-tuning work for larger models?
    6. Can an automatic detector tell good writing from bad?
12. References

The result is called qwen3-4b-deslop and weighs 2.5 GB in its quantized version. Anyone can download it with Ollama and compare, prompt by prompt, how it responds versus the original model. This isn’t a closed lab experiment: it’s a public model that runs on a laptop.

TL;DR

• Qwen3-4B-deslop’s AI slop score drops from 121 to 12.5 per 1,000 words after fine-tuning.
• Em dashes disappear completely: from 20.5 per 1,000 words to zero.
• RLHF rewards a tone that sounds “helpful,” and that bias is the root of AI writing tics.
• A LoRA trained on 161 filtered responses removes the clichés without touching the knowledge: it scores 30/30 on a quiz.
• Ollama runs the quantized model (2.5 GB) on your laptop so you can compare before and after on your own prompts.

What are AI writing clichés?

AI writing clichés are style fragments that a language model repeats so often they give away its artificial origin: the em dash as a dramatic pause, triplets of adjectives, the “it’s not X, it’s Y” formula, and questions the text immediately answers itself.

It’s similar to what happens with a salesperson who learns, by repeating the same pitch over and over, which phrases make most people nod along even though they say nothing new. The model doesn’t understand that these phrases are empty: it only knows that, during training, they raised its score.

These aren’t random errors. They come from the same training process, which is why they show up in the same form across models from different labs. Understanding where they come from is the first step toward removing them without damaging what the model actually knows.

Why they show up: RLHF’s bias toward human approval

The fine-tuning that gives a model its “assistant voice” is called reinforcement learning from human feedback (RLHF). A group of people rates pairs of responses, a reward model learns to predict those ratings, and the final model is adjusted to maximize that score.

The problem is that human raters don’t read with the same attention as an editor. They reward responses that “feel” complete and confident, and certain surface-level flourishes create that feeling without adding any real information. A triplet of adjectives sounds thorough. A question answered in the same sentence sounds instructive. An em dash in the middle of a sentence sounds reflective. None of that adds a fact, but it does raise the average rating.

That’s why AI writing tics aren’t a quirk of any one model, but the statistical byproduct of optimizing for the average taste of thousands of raters. And since the process repeats at every lab with similar methodologies, the same habits show up in models that never shared code or training data.

How the targeted fine-tuning works to remove them

Before touching the model’s weights, the author tried two shortcuts that don’t require retraining anything. The first was “activation steering”: subtracting, during generation, the internal direction that corresponds to the “assistant voice,” combined with a system prompt asking for a plain style. It works, and brought the score down to around 15, but it needs that prompt and that code running on every single response, and it also skews the model’s predictions on normal text that has nothing to do with style.

The second shortcut was more surgical: checking neurons one by one until finding four whose activation, when flipped, eliminates 70% of “it’s not X, it’s Y” cases at almost no cost. But that patch only works for that specific cliché and doesn’t generalize to the rest of the habits.

To fix it permanently, inside the weights and without runtime hooks, the author used distillation. A “teacher” model (built from whatever had worked best up to that point) generates responses to a set of training prompts. The responses that pass quality filters feed a small LoRA adapter, which learns to produce that same style from the original prompt, without the teacher or the extra code.

flowchart TD
A["Teacher generates 3 responses per prompt"] --> B["Filter: slop score under 12"]
B --> C["Filter: no harm (drift and 30-question quiz)"]
C --> D["Filter: response meets the requested task"]
D --> E["LoRA learns from the approved subset"]
E --> F["Student model Qwen3-4B-deslop"]

The first round of this process, without a style hook or prompt steroids, already brought the score down to around 20. That was proof that distillation works better than forcing style at runtime.

flowchart LR
R1["Round 1: score near 20"] --> R2["Round 2: score 9.9, but fails task adherence"]
R2 --> R3["Round 3: score 12.5, task adherence at 80%"]

The writing-tic detector: how the score is measured

To know whether the model improved, you have to measure, not just look. The detector the author uses measures AI writing patterns with a weighted rule set. It counts em dashes, occurrences of “it’s not X, it’s Y,” three-item triplets, rhetorical questions answered in the same sentence, transition clichés like “here’s the key thing,” and filler words like “delve” or “seamless.” Each habit carries a different weight, and the sum is normalized per 1,000 words.

A rule-based detector can’t tell good writing from bad on its own, so the author also manually reviewed a sample of responses in each round. A regex can count em dashes, but it can’t tell whether the paragraph around them actually makes sense.

flowchart LR
T["Generated text"] --> H1["Counts em dashes"]
T --> H2a["Counts 'it's not X, it's Y'"]
T --> H3a["Counts self-answered questions"]
H1 --> S["Weighted sum"]
H2a --> S
H3a --> S
S --> P["Score per 1,000 words"]

To illustrate the idea, here’s a simplified detector in Python that anyone can run on their own paragraph:

import re

def slop_score(text):
    words = len(text.split())
    em_dashes = text.count("-")
    not_x_but_y = len(re.findall(r"not .*?, but", text, re.IGNORECASE))
    rhetorical = len(re.findall(r"\?\s*[A-Z]", text))
    raw = em_dashes * 3 + not_x_but_y * 4 + rhetorical * 2
    return round(raw / words * 1000, 1)

text = "The framework isn't just fast, it's, above all, elegant. Why does it matter? Because it solves three problems: speed, memory, and readability."
print(slop_score(text))

With that example paragraph (which packs in an em dash and a self-answered question), the function returns 227.3. It’s a ten-line toy, not the author’s real detector, but it shows the principle: count patterns, don’t judge the topic.

Practical examples: before and after

The author tested the model with 40 prompts it never saw during training, spread across ten topics and four genres: product review, personal post, opinion piece, and email. In the original model, an opinion piece about a company’s new CRM (see the breakdown in the original post) never took a stance: it read like an incident report, full of em dashes and benefit triplets.

An intermediate version of the model, trained before the filters were properly tuned, swung to the other extreme: it brought the slop score down to 9.9, but started inventing facts. It cited a study from a university that doesn’t exist, and chained almost every sentence with “, which,” 28 times more often than the original model. That new habit came from the very prompt the author gave the teacher, which asked it to connect sentences “with because, so, but, which,” and two rounds of imitation had amplified it unintentionally.

The task-adherence filter added in the third round isn’t a style detector, but a set of genre-specific rules. An email has to open with a greeting. A personal reflection has to be in first person. An opinion piece has to take a stance early. And the length has to roughly match what the prompt asked for. Those rules, combined with counting “, which” connectors and invented studies, are what caught the problem with the intermediate version.

The final version, trained with that additional filter, barely rose from 9.9 to 12.5 on the slop score, but recovered task adherence: from the intermediate version’s 60% to the original model’s 80%. The “, which” connectors dropped from 1.4 to 0.3 per 100 words.

⚠️ Heads up: optimizing only for the slop score, without checking whether the response actually completes the task, produces a model that writes plainly but invents facts and avoids taking a stance.

Getting started: running Qwen3-4B-deslop on Ollama

To try it you need Ollama installed. On Linux and macOS, the command is:

curl -fsSL https://ollama.com/install.sh | sh

On Windows, the installer downloads directly from ollama.com/download. With Ollama running, the quantized model (2.5 GB) downloads and starts with a single command:

ollama run hf.co/erikkannike/qwen3-4b-deslop-v4-GGUF:Q4_K_M

The first time, Ollama downloads the model’s manifest and layers, verifies their integrity, and saves them to disk. Once it’s done, it opens an interactive prompt where you can type directly. To compare against the original model, just run in another terminal:

ollama run qwen3:4b

And ask both the same question. The difference in style between the two responses (the original packed with em dashes and triplets, the deslop version flatter and more direct) is the experiment the author invites everyone to repeat.

To confirm what got downloaded, ollama list shows the model name, its size, and the modification date in a text table. And ollama show hf.co/erikkannike/qwen3-4b-deslop-v4-GGUF:Q4_K_M prints the quantization, context size, and model family.

Real use cases

The most direct use case is editorial quality control: running an AI-generated draft through a synthetic-writing detector before publishing it, the same way you’d run a linter over code before a commit. A publication or a tech channel can use it as an automatic filter before a human editor reviews the text.

It also works as a base for custom fine-tuning. The LoRA behind qwen3-4b-deslop is small, and the method (a teacher that generates, filters that approve, an adapter that learns) can be applied to any style you want to reinforce or eliminate: not just writing tics, but also corporate jargon, a specific brand tone, or a consistent output language.

And there’s an educational use case, which is what motivates this article: running the original and deslop models side by side shows, in real text rather than a benchmark table, exactly what effect fine-tuning has on an AI’s style.

Common mistakes and best practices

• Measuring only style: a slop detector won’t tell you if the model invented a fact or dodged what it was actually asked. A task-adherence check is needed in parallel, not afterward.
• Trusting the teacher’s prompt without auditing it: the habit of connecting every sentence with “, which” came from the very prompt that asked for varied connectors. Reviewing the teacher’s responses before using them for training prevents amplifying a new bias.
• Using a single harm filter: a knowledge quiz won’t catch that the model stopped taking a stance in an opinion piece. Genre-specific checks are needed.
• Treating the score as absolute truth: a regex counts patterns, not quality. Manually reviewing a sample in every training round is still necessary.

Comparison: three ways to remove a model’s mannerisms

Going deeper: the hidden direction inside the weights

An earlier finding from the same author, in a prior experiment on this model, found something more structural than a simple style preference: the “assistant voice” exists as a measurable direction within the model’s activation space. Subtracting it mathematically during generation changes the response’s style, the same way moving an object across a coordinate plane changes its position without changing its shape.

The four-neuron patch is a more narrow case of the same idea: for the “it’s not X, it’s Y” habit specifically, flipping the activation sign of four neurons is enough to eliminate 70% of cases. But that solution is fragile because it’s tied to that single cliché and doesn’t generalize to em dashes or triplets.

💭 Key point: the existence of an internal direction for style doesn’t mean every cliché shares that same direction. Each habit can live in a different part of the network.

That’s why distillation turns out to be more robust than locating neurons or directions. It doesn’t need to find the exact location of each habit inside the network: it’s enough to show the model, through real examples, what the desired result looks like.

Your next step: run ollama run hf.co/erikkannike/qwen3-4b-deslop-v4-GGUF:Q4_K_M, ask it and ollama run qwen3:4b the same opinion question, and count by hand how many em dashes show up in each response.

Frequently Asked Questions

What does it mean for a model to have AI writing clichés?

It means it repeats, more often than a human writing carefully would, a small set of style devices: em dashes, triplets of items, the “it’s not X, it’s Y” formula, and questions it answers in the same sentence. An automatic detector can count these and produce a score per 1,000 words.

How is Qwen3-4B-deslop trained to avoid these tics?

Through three rounds of distillation: a teacher model generates responses, a set of filters discards the ones with clichés, invented facts, or that fail the requested task, and a small LoRA adapter learns to imitate the responses that remain. The result gets baked into the model’s weights, with no prompt or extra code needed at runtime.

Does it perform the same as the original model on factual questions?

According to the author, it answers 30 out of 30 questions correctly on a knowledge quiz, the same score as the original, unmodified model.

Is it free to run Qwen3-4B-deslop on Ollama?

Yes. The model is published on Hugging Face in a public repository, and the quantized version weighs 2.5 GB; you just need Ollama installed and enough disk space.

Does this kind of fine-tuning work for larger models?

The author trained this experiment on a MacBook Air, with a 4-billion-parameter model and 161 training responses. The recipe doesn’t depend on model size, though testing it on larger models remains future work.

Can an automatic detector tell good writing from bad?

Not on its own. A rule-based detector counts patterns, it doesn’t judge meaning or coherence, which is why the author paired every training round with a manual review of responses.

References

• 100toolkit.com: the original writeup with the full methodology, each round’s scores, and links to the model weights.
• Hugging Face: repository with the quantized Qwen3-4B-deslop weights in GGUF format.
• Ollama: official documentation for installing and running language models locally.
• Wikipedia: general explanation of reinforcement learning from human feedback (RLHF).
• GitHub, QwenLM/Qwen3: official repository for the Qwen3 model family this fine-tuning was built on.

📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day. @programacion

Featured image: Foto de Logan Voss en Unsplash