How I Turned AI Writing Tells into a Pre-Read Quality Gate

If a draft is going to sound machine-made, I want to catch it before an editor spends time on it.

That is the idea behind a small “humanizer skill” I use in my content workflow: every AI draft starts at 100, then loses points for each writing tell the rubric detects. It is not a magical detector, and it is not trying to prove authorship. It is a practical gate that helps my team decide whether a draft is ready for a human reader, needs a rewrite, or should be rebuilt from scratch.

The detail that makes the whole thing useful is also the easiest to overlook: the rubric is not built around vague “AI vibes.” It is based on specific patterns.

What the skill actually does

The skill lives in a single Markdown file, humanizer.md, inside a content ops folder in my open-source ai-marketing-skills repo. It is meant to be loaded by an AI agent before the agent writes.

At a high level, the process is simple:

1. Start every draft at 100.
2. Subtract points for each AI-writing pattern.
3. Stack repeated uses of the same pattern, up to twice the base penalty.
4. Read the score before anyone reads the draft.

That last step matters because the score is not the final judgment. It is a triage signal.

The rubric sorts results into four bands, and one of those bands is blunt: anything under 50 “Reads like ChatGPT output.” In practice, that is the point where I stop trying to polish the draft and treat it as a rewrite candidate.

Why the rubric is grounded in specific tells

I did not invent the pattern list from scratch. The file turns Wikipedia’s public page on Signs of AI writing into 24 scored patterns.

That page groups writing tells by type, which is helpful because it makes the problem observable instead of abstract. It flags things like:

• puffed-up claims about legacy or importance
• vague credit to unnamed experts
• overused words
• odd formatting
• chatbot habits like “I hope this helps”

It also tracks how some overused words shift across model generations. One example is “delve,” which the page says faded after 2024.

For a developer or content operator, this is useful because it gives you a concrete feature set. You are not asking, “Does this feel AI-like?” You are checking for known artifacts.

The weighting is the part I agree with most

The rubric does not treat every tell as equally serious.

The heaviest penalties, 10 points each, go to signals a reader notices immediately, such as a fake sense of importance or a leftover “I hope this helps.” An extra em dash costs half as much. That weighting feels right to me because one puffed-up claim can make me doubt everything else in the paragraph.

This is also where the system becomes more useful than a simple blacklist. A draft with a few cosmetic issues is not the same as a draft that overstates its significance or leans on generic filler. The scoring reflects that difference.

My least favorite pattern

The pattern I dislike most is negative parallelism: a sentence that tells you what something is not before it gets around to what it is.

The version I called out on X was the classic form: “It’s not X, it’s Y.”

The rubric docks 5 points per use, up to the 10-point cap. My editors at Single Grain treat it as a hard ban in titles and body copy, even though the scoring itself is more forgiving. If your team’s drafts are full of this structure, I would start there.

Why? Because it often makes copy feel clever without making it clearer. The sentence spends its energy on contrast instead of definition.

How the gate fits into a real workflow

This is not a standalone detector bolted on after the fact. It is a pre-write and pre-review step.

In my workflow, the agent loads the humanizer skill, applies the scoring prompt, then reports the score before the draft is handed off. That means editors are not wasting time manually deleting “delve,” trimming repetitive closures, or smoothing out awkward machine habits one by one.

The useful part is not just the score. It is the order of operations.

When the score is low, the draft gets rewritten before editing starts. When the score is middling, the team can focus on the worst offenders. When the score is strong, editors can spend more time on the actual substance: facts, structure, and reader value.

Setup is simple, but the limitation is important

The file is written for Claude Code, Anthropic’s coding agent, but the setup is portable as long as the agent can read a file.

The basic steps are:

1. Give the agent the humanizer.md file or a downloaded copy.
2. Paste the scoring prompt into the agent’s memory or project instructions.
3. Read the score report before the draft.

That is enough for a lightweight implementation. If you want the full setup, the repo README says to clone the skill folder and copy it whole when a skill bundles scripts or reference files, which this one does.

There is a tradeoff here: the rubric is useful, but it is still descriptive, not magical. Wikipedia’s own page says the list is based on observations, not certainty. It also cites a 2026 study where people identified AI text no better than chance, and it notes that detection tools have non-trivial error rates.

So I would not use the score as a proof of origin. I would use it as a quality gate for writing behavior.

The main constraint I keep in mind

The score only helps if you treat it as a filter, not a verdict.

A draft can still be weak for reasons the rubric does not catch. It can also be unfairly penalized for a stylistic choice that happens to overlap with a machine tell. That is why I prefer a scoring system that feeds a human review process instead of replacing one.

The upside is that this approach gives the team a shared language. “It scored 43” is more actionable than “it feels off.”

Why this is worth doing

The best outcome is not that every draft becomes perfectly human-sounding. The best outcome is that readers get drafts they can trust, and editors spend their time improving ideas instead of stripping out repetitive machine habits.

That is what this humanizer skill is for: score the draft first, catch the tells early, and reserve human attention for the parts that actually matter.

If you are building your own content workflow, the small implementation detail worth copying is the scoring gate before the edit, not after it.

Tags: #aiwriting #contentops #developerproductivity #automation