The AI Text Iceberg

A typical AI draft shows what separates the three layers:

The tool offers seamless integration. It efficiently optimizes processes. Furthermore, it sustainably boosts productivity. Overall, it enables companies to unlock their full potential.

At the tip, words and patterns stand out: seamless, furthermore, sustainably, full potential. The measuring layer shows that the sentences run to similar lengths and follow the same build. In the judging layer, a different question arises: what exactly was integrated, for whom, with what result — and is the claim backed by anything at all?

The same piece of text. Three different ways of looking at it. By judging I don't mean passing a final verdict, but forming a reasoned judgment in context.

That's why an AI detector is not necessarily one method. Some tools work almost entirely with heuristics. Others compute metrics, or let a statistical model derive an origin estimate from them. Still others put a large language model in the judge's seat. Commercial products may blend several layers without disclosing which part carries how much weight. So if you want to evaluate a detector, ask first: which layer does it work on — and what does it claim to be able to conclude from its result? What separates the layers is not always the signals themselves, but how a tool processes them and what conclusion it draws.

Heuristics are rules of thumb. They look for things that frequently stand out: straight quotation marks in German body text, recurring sentence openers, an excess of subheadings, or formulas like in summary, it can be said.

None of this requires AI. A small checking program can flag such patterns quickly and reliably. Its output is also traceable: it doesn't just show a number, it points to the exact spot where a rule fired.

But two kinds of rules live at the surface, and they shouldn't be confused.

The first kind checks relatively stable conventions. Mismatched quotation marks, double spaces, a date in the wrong format. Rules like these age slowly.

The second kind hunts for fashionable AI traces: certain favorite words, transition formulas, or sentence patterns. These rules age quickly. Seamless may be conspicuous today and vanish from the models tomorrow. A new favorite word will take its place.

So what's stable is not "the heuristic" as such. Only its hard core is stable. The edges shift with models, prompts, text types, and writing habits.

The next layer is less intuitive, but more robust. Here, the tool no longer just looks for individual warning signs. It counts or computes properties of the text.

For example:

• How long are the sentences, and how much do they vary?
• How often do sentences open the same way?
• How many passive constructions are there?
• How far apart do the two halves of a German verb bracket sit (say, between hat and bezahlt)?
• How predictable is the word sequence for a particular language model?

"Measuring" doesn't automatically mean "objective truth" here. At first, it only means this: the same text, the same method, the same version, and the same settings produce the same value. The result is reproducible. Its interpretation can still be wrong.

A speedometer reliably measures 80 kilometers per hour. Whether that's fast or slow depends on whether you're on a highway, a country road, or in a school zone.

Texts work much the same way.

Perplexity: how predictable is the next step?

Perplexity can be explained as a surprise score. A language model looks at what has been written so far and estimates how likely the possible continuations are.

In the morning, I like to drink …

If the next word is coffee, that's hardly surprising. If it's cactus juice, it's more surprising. Put simply: the more predictable the continuations, the lower the perplexity. The more unexpected they are, the higher it climbs.

That can be interesting, because language models tend to pick likely phrasings. But the value proves nothing. A government form is also highly predictable. A carefully revised AI text can contain unusual phrasings. And different reference models can score the same text differently.

So perplexity doesn't measure "human or machine." It measures how predictable a text looks to a particular model.

Burstiness: how steady is the text's pulse?

Burstiness usually refers to how much sentence length and complexity fluctuate; some tools also use it for how much predictability varies from passage to passage. A text can be very evenly paced: ten words, twelve words, eleven words, ten again. Or it can jump around more:

Short. Then comes a longer sentence that picks up a side thought, puts it in context, and only returns to the actual point late. Done.

Shifts like that often feel more alive. But the same caveat applies: variation is neither automatically human nor automatically good. An instruction manual can afford to be evenly paced. A human technical writer can write with great control. And a language model, when asked, can mix short and long sentences.

Burstiness describes a text's rhythm. Not its author.

Grammar and readability — hard values, soft meaning

Grammar tools produce metrics too. They can identify sentence parts, flag passive forms, or count repeated constructions. Readability formulas compute sentence and word lengths. Word lists show how common or rare an expression is in reference texts.

All of this is useful, as long as you don't read more into it than was measured. A long sentence can be hard to follow — or precise. A rare word can sound pretentious — or be technically necessary. A passive sentence can obscure responsibility — or be exactly the right form for describing a process.

At some point, even a good comparison is no longer enough. Then the questions are not:

• How long is the sentence?
• Is the name still there?
• Does the version resemble the writing sample?

But:

• Is the claim concrete enough?
• Does the tone fit the readers?
• Is the example convincing?
• Are uncertainties named honestly?
• Does this paragraph serve the purpose of the text?

These are questions of judgment. Within an automated check, large language models are best positioned to work on them, because they can weigh many signals together and give reasons in plain language. They don't just flag the example paragraph as uniform — they ask: Which integration? Which processes? How was productivity measured? And then they can propose a more concrete version.

That is the strength of judging: it connects text, context, and likely effect.

Judging and generating are not the same task, though. A model can recognize that a paragraph stays generic without writing a better one. When rewriting, it additionally has to preserve facts, hit tone and text type, and decide which information is missing. The broader the field of use, the more context this step needs.

And that same connection is also the weakness of judging. A language model isn't measuring a fixed property here. It generates a plausible judgment. That judgment depends on the instructions, the model, the context provided, and learned preferences. Without clear guidance, it often favors the smooth middle path. It can treat an idiosyncratic voice as an error, fill in missing facts, or feign certainty where doubt would be appropriate.

Why my little critic failed

At this deepest layer of ice, I wanted to deploy my own small model. It was supposed to recognize whether a text sounds natural and good. The plan ran into three problems.

First: a model learns labels, not intentions. Readily available datasets mostly distinguish categories like "human" and "AI." A model can use them to learn to guess origin patterns. But it doesn't automatically learn what makes a text good for a particular reader. Origin and quality are two different targets.

Second: a borrowed judge stays borrowed. I could have a large language model rate thousands of texts and train my small model on those verdicts. But then it would mostly inherit its teacher's standards and blind spots. Hand-checked examples, multiple raters, and pairwise comparisons can improve this. They don't produce an independent notion of quality by themselves.

Third: quality changes with context. A terse sentence can be strong on a landing page and inadequate in a contract. Technical vocabulary can needlessly weigh down a blog post and be indispensable in technical documentation. A narrowly trained model can work well in its specialty. A general judge for arbitrary German texts, however, needs a great many text types, purposes, and robust human ratings.

So I would have traded a manageable problem for a bigger one: instead of maintaining rules, I would have had to permanently maintain a high-quality evaluation dataset.

A small model of your own can still make sense — as a pre-sorter for very large volumes of text, for a narrowly defined use case, or when texts have to stay local for privacy reasons. Then it's a bouncer turning texts away at the door. It is not a universal judge of good style.

Beneath the deepest layer of ice lies the ground that carries every judgment: the human.

Only the author or client knows what the text is meant to achieve. Only they can say what was actually experienced, which source holds up, which promise can be kept, and which phrasing matches their own stance.

The large language model can process context. But it has no intent of its own for this text. It can imitate a voice. It hasn't lived that voice. It can cite a source. It doesn't bear the consequences if the source is wrong or the claim misleading.

That's why "good" is not a temperature that sits inside the text, waiting to be read off by an app. A text is good for someone, in a situation, for a purpose. Without these three reference points, every quality score falls short.

This also changes the question of origin. Many texts today are made collaboratively: a human sketches, a model drafts, the human adds experience, a tool checks facts, an editor tightens. In cases like these, "human or AI?" is no longer a clean property of the finished text, but a question about the process behind it.

Where rules require disclosure — in schools, universities, research, or companies — that process remains important. But it cannot be reliably reconstructed from the text alone. What matters then is not just how the text sounds, but whether it was made transparently and who stands behind it.

What actually makes an AI draft more human

A text doesn't become more human because you plant deliberate typos, scatter rare words, or randomize sentence lengths. That would just be a new surface — this time built specifically for the detector.

A text becomes more human where real decisions become visible:

1. Concreteness instead of marketing fog. Not "boosts efficiency," but: what got faster, for whom, and by how much?
2. Experience instead of borrowed certainty. What did you observe? Where did something fail? What remains open?
3. A stance instead of neutral polish. Which trade-off are you making, and why?
4. Rhythm instead of dice-rolled variation. A short sentence is short because it makes a point — not because a metric demands more variance.
5. Responsibility instead of camouflage. Facts stay verifiable, sources get named, and AI use is disclosed where it's relevant or required.

The marketing paragraph from the beginning could then — provided the numbers are true — become something like:

In the pilot test, the support team migrated 300 existing tickets in twelve minutes. Previously, the import took about 45 minutes. Two custom fields still had to be corrected manually afterward.

This paragraph doesn't sound more human because it's more irregular. It names an observable event, an order of magnitude, and a limitation. That information is exactly what no humanizer can honestly invent; it has to come from the human.

For my Humanizer, this settles the order of operations. First it protects names, numbers, and claims. Then it flags visible patterns. After that, it measures and compares structure, meaning, and style. Only then does a large language model propose changes. In the end, a human decides what stays.

No layer replaces another. And no single layer gets to act as if it were the whole iceberg.

The four sentences that remain

1. Heuristics read traces. They point out anomalies, but they don't prove origin.
2. Metrics describe properties. Perplexity, burstiness, or sentence length say something about patterns, not about the author.
3. Language models can judge. They connect context and language, but they deliver reasoned suggestions, not final truth.
4. The human carries the text. Purpose, experience, sources, and responsibility rest on the seafloor.

My original mistake was wanting to turn a small model into a judge. These four sentences describe the more modest architecture that grew out of it.

The deeper the question reaches, the less a single detector score helps. And the clearer it becomes what a good text really depends on: not whether it successfully appears human, but whether it is concrete, verifiable, and owned.

The Humanizer this story is about: German AI text humanizer in the Lab