The Signs of AI Writing (and AI Code): A Field Guide to the Tells

The clearest signs of AI writing are a small, repeatable set of tells: pet words like "delve," "tapestry," and "leverage"; clusters of em dashes; everything forced into groups of three; dodging the word "is" ("serves as a testament to"); stacked hedging; and paragraphs that all open and close the same way. One of these is a coincidence. All of them at once is a fingerprint — and the same thing happens in AI-generated code, which almost nobody talks about.

If you've felt that "an AI wrote this" itch without being able to name why, this is the field guide. It's the written-and-code cousin of AI design slop — same homogenization, different medium.

The tells, named

AI text isn't bad, exactly. It's average — confidently, relentlessly average. Here's what that looks like up close:

• Pet vocabulary. "Delve," "tapestry," "realm," "navigate the landscape," "underscore," "testament to." Not because they're wrong, but because models reach for them far more than people do.
• Copula avoidance. It won't say something is a thing. It "serves as," "stands as," "represents." Plain "is" reads as more human than you'd think.
• The rule of three, forced. Every list is three items. Every sentence has three clauses. Real writing has lumpy counts — two here, five there.
• Em-dash clusters. One em dash is fine. Three in a paragraph, used as all-purpose glue, is a tell.
• Hedging stacks. "It's important to note that, generally speaking, this can sometimes..." Confidence got sanded off.
• Same-shaped paragraphs. Topic sentence, three supporting sentences, tidy wrap-up — over and over, like a worksheet.
• The promotional reflex. "In today's rapidly evolving landscape" openings and "the future looks bright" closings, with no actual claim in between.

None of these is a crime alone. Stacked, they're the signature.

A 30-second spot check

You don't need a detector. Read a page and tally the tells. A rough human-ness scale:

• 0–3: Obviously AI — multiple pet words, robotic three-beat rhythm, hedge soup.
• 4–5: AI-heavy — a few human touches, but the bones are generic.
• 6–7: Mixed — could go either way, no strong voice.
• 8–9: Human — natural rhythm, specifics, an opinion.
• 10: Indistinguishable from a good human writer.

The trick most people miss: not every tell weighs the same. "Delve" is a dead giveaway. "Additionally" is just mildly suspicious. Weight them so the giveaways count for more, and "this feels AI" turns into a number you can actually move. (That weighting is exactly how I built Slopbuster, the tool version of this checklist.)

The part nobody covers: AI-generated code has tells too

Everyone hunts AI prose. Almost no one talks about the fact that AI-generated code has its own fingerprints — and they're just as spottable once you know them:

• Tautological comments. // increment counter above counter++. The comment narrates the obvious because the model fills space.
• Verbose, hedge-y naming. userDataObject, dataManager, handleProcessData. Real engineers say user.
• Vague commits. "improve," "update," "various changes," "enhance functionality." No commit a human under deadline actually writes.
• Docstrings that restate the signature. A param doc that says "userId (string): the user ID" tells you nothing the type didn't.
• Suspicious symmetry. Every function the same length, every branch handled with the same shape, placeholder values like foo/example.com left in.
• Happy-path-only tests. Mocks everywhere, no edge cases, asserts that the sun rose.

This is the open lane. If you're reviewing a PR and something feels off but compiles fine, run the same instinct you use on prose: look for the tells. (Slopbuster ships 80+ of these code patterns — the thing the text-only humanizers don't touch.)

How to fix it: two passes, not one

Here's where almost every "humanizer" goes wrong. They do one pass: find the AI patterns, replace them, done. But strip the slop and you don't get human writing — you get sterile writing, which is just as detectable, only by a different classifier. Bland is its own tell.

The fix is two passes:

1. Remove the slop. Kill the pet words, break the three-beat rhythm, cut the hedges, vary the paragraph shapes.
2. Add the soul. Put a voice back in — a specific example instead of a vague reference, a real opinion, a short sentence next to a long one, a contraction, the occasional fragment.

Watch a stock corporate line climb: "In today's rapidly evolving digital landscape, leveraging AI is crucial" scores about a 3.8. Cleaned up, it's a flat 6.2. Rewritten with a concrete result and an actual point, it's an 8.4. The first pass removed the slop. The second added the soul.

Frequently Asked Questions

What words are overused by AI?

The biggest pet words are "delve," "tapestry," "realm," "leverage," "underscore," "navigate" (as in "navigate the landscape"), "testament to," "boasts," and "elevate." On their own they're ordinary; the tell is the frequency and the clustering. AI also overuses "Additionally," "Moreover," and "Furthermore" as paragraph glue, and leans on em dashes far more than most people do.

What makes AI writing so obvious?

Less any single word, more the pattern: everything grouped in threes, paragraphs all shaped the same way, the word "is" avoided in favor of "serves as" or "represents," hedging stacked on hedging, and a promotional reflex ("in today's landscape…", "the future is bright") wrapped around very little actual content. It reads as confidently average.

How can you tell if code is AI-generated?

Look for the code-specific tells: comments that narrate the obvious (// increment counter), over-descriptive variable names (userDataObject), vague commit messages ("improve," "various changes"), docstrings that just restate the type signature, suspiciously uniform function shapes, leftover placeholder values, and tests that only cover the happy path. Any one is common; the whole set together points at generation.

Is it bad to write with AI?

No — the problem isn't using AI, it's shipping the first draft. AI is great for getting to a draft fast. The fix is a verification pass: spot the tells, then rewrite to remove the slop and add a human voice before it goes public. Generate fast, verify with evidence.

---

Slopbuster turns this whole field guide into a tool — 100+ writing tells, 80+ code tells, weighted scoring, two-pass rewrite. See the project, or read its visual sibling, Pixelslop. Reference: Wikipedia's Signs of AI writing.