The Feature Engineering Inside a Trained AI Classifier: From Raw Text to Probability

An AI detector doesn’t read your essay. It can’t. Before any model decides anything, your sentences get shredded into a list of numbers — and that translation step, called feature engineering, is where the real action happens. Understand it, and the whole “97% AI” verdict stops feeling like magic. It starts looking like what it is: arithmetic on patterns.

Key takeaways

• A trained classifier converts your writing into a list of numbers (features), then guesses from those numbers. It never understands your meaning.
• Features cluster into a few types: statistical, lexical, syntactic, and learned embeddings.
• No single feature decides the call. The model weighs them all and outputs a probability between 0 and 1.
• Because the features measure predictability and uniformity, careful human writing can land in the same numeric zone as AI text.
• The edits that lower your score honestly are the same ones that help readers: more specific detail, more real sentence variety.

From words to numbers: what “feature engineering” means

Machine learning models don’t take text. They take vectors — ordered lists of numbers. So the first job of any AI detector is to turn your paragraph into something a model can chew on. That conversion is feature engineering: deciding which measurable properties of the text to extract, and how to represent them as numbers.

Think of it like a blood panel. The lab doesn’t “read” your health. It measures a fixed set of values — glucose, cholesterol, white-cell count — and a model (or a doctor) interprets the combination. An AI detector does the same thing to your writing. It picks a battery of measurements, runs them on your text, and hands the resulting numbers to a classifier that was trained to separate “human” panels from “AI” panels.

Which features to measure is the part humans design. How to weigh them is what the model learns during training. Both matter, and both are why two detectors can stare at the same paragraph and disagree.

The four families of features

Most detectors draw from a few recognizable buckets. You don’t need the math to grasp what each one is measuring.

Statistical features: how predictable is the text?

This is the oldest and most famous family. Perplexity estimates how surprised a language model is by your next word; lower perplexity means more predictable, which correlates with machine generation. Burstiness measures how much that surprise varies sentence to sentence — humans tend to spike and dip, machines tend to hold a steady hum.

These two get the most press, and they’re worth understanding on their own. For the worked-example version, we covered perplexity and burstiness, explained with worked examples in its own piece. Here, just file them as two numbers among many.

Lexical features: which words, how often

These count word-level habits. Type-token ratio (unique words versus total words), how often you reach for rare versus common words, repeated phrases, contraction rate, punctuation density. AI text often carries a recognizable lexical signature — slightly flattened vocabulary, a fondness for certain connective words, a suspiciously even spread.

Syntactic features: the shape of sentences

Here the detector looks at structure rather than content. Average sentence length and how much it varies, depth of clause nesting, the mix of parts of speech, how sentences open. Start six sentences in a row with “The” or “This” and you produce a distinct syntactic fingerprint — a number the model can see even though no human flagged it by hand.

Learned embeddings: the dense fingerprint

This is the modern heavyweight. The detector runs your text through a language model, which outputs an embedding — a long list of numbers (often hundreds of dimensions) that encodes meaning and style in a form the model worked out on its own. Nobody hand-defined what dimension 248 represents; the model figured out during training that it’s useful. Embeddings are powerful precisely because they catch subtle patterns the hand-built features miss. They’re also why detector behavior can feel like a black box.

A mini-scenario: one sentence, two ways

Say you submit this: “The industrial revolution changed society in many ways.”

Here’s roughly what gets extracted:

• Statistical: very low perplexity — every word is the expected next word. Low burstiness if the neighboring sentences run similar lengths.
• Lexical: common words throughout, the vague quantifier “many ways,” nothing rare or specific. High frequency, low information.
• Syntactic: simple subject-verb-object, opens with “The,” medium length, no variation.
• Embedding: lands near a dense cluster of generic, low-specificity statements the model has seen a million times.

Now rewrite it: “Between 1760 and 1840, steam power gutted the cottage weaver’s livelihood — and built Manchester’s slums in the same breath.”

• Statistical: perplexity jumps; “gutted,” “cottage weaver,” and “Manchester’s slums” are far less predictable. Burstiness rises against shorter neighbors.
• Lexical: rare, specific words and a real date. Higher information density.
• Syntactic: a dash, a clause that turns, an unusual rhythm.
• Embedding: drifts toward a region the model associates with specific, lived-in human writing.

Same idea. Completely different feature vector. The second version isn’t “tricking” anything — it’s genuinely more specific, and the numbers reflect that because specificity is real.

How the features become a probability

Once the text is a vector, the classifier takes over. During training it saw thousands of human-written and AI-written examples, each already converted to features, each labeled. Its whole task was to learn a boundary in that high-dimensional space — a surface where human examples mostly fall on one side and AI examples on the other.

When your text arrives, the model checks which side of that learned boundary your feature vector lands on, and how far. Close to the human cluster, you get a low score. Deep in the AI region, a high one. The output gets squeezed into a number between 0 and 1, which the tool dresses up as a percentage.

That’s the crucial point: the probability isn’t a measure of truth. It’s a measure of similarity to past examples. A 0.9 means “in this model’s learned space, your vector sits much closer to the AI examples than the human ones.” It is not a confession. It’s a comparison. And if your honest, careful writing happens to produce uniform, predictable features, it can sit in the AI region for reasons that have nothing to do with how you actually wrote it.

This is also why detectors report probabilities rather than verdicts. OpenAI retired its own AI-text classifier in July 2023 because its accuracy was too low to trust. A 2023 study by Weixin Liang and colleagues at Stanford (senior author James Zou) found several detectors flagged non-native English writers far more often than native ones. Both are what you’d expect when authorship is judged from surface features that only loosely track how a text was produced.

Why this matters for how you write and edit

If the model only ever sees engineered features, then the lever you control is the features themselves — and the honest way to move them is to write with more genuine variety and specificity.

A concrete number, a named place, a date, a short punchy sentence dropped after a long winding one: each of these shifts your lexical, statistical, and syntactic features at once, because each is a real property of better writing. You’re not stuffing keywords into a hidden slot. You’re making the text less uniform, which both the math and a human reader register as more alive.

That overlap is the whole point. The features detectors measure are crude proxies for things good editors already chase. Want the broader picture of the pipeline? There’s more on how detection actually works across our other posts, and if you’re weighing tools, here’s what each plan includes.

Frequently asked questions

The structured FAQ below answers the common questions in detail: what a feature actually is, whether detectors read your words or just the statistics, why two tools disagree on the same text, how to change your features without faking anything, and what the final probability really represents.

The short version

A trained AI classifier is a number machine wearing a verdict’s clothing. It chops your writing into statistical, lexical, syntactic, and embedding features, weighs them against the examples it trained on, and reports how similar you look to its idea of “AI.” Knowing that, you can stop chasing a magic score and start doing the thing that actually moves the features and the reader at the same time: write with specifics and real rhythm.

Curious where your own draft falls — and which exact sentences are dragging the number up? Paste it into PaperBleach and find out.