Iron Goo
P3E08 · Part 3: AI SEO

AI content checks for SEO can pass tests and still be wrong

AI content checks can approve copied drafts and reject good writing even when every unit test passes. Learn how to test SEO quality gates against real content, calibrate AI classifiers and catch defects that only appear across a batch.

What this episode covers

  • Cheap rules first, with AI classifiers for narrow questions.
  • Why containment catches copying that Jaccard similarity can miss.
  • Testing checks across your corpus and every input they might reject.
  • Finding impossible rules, conflicting gates and results that change with processing order.
  • Measuring false alarms and missed defects with labelled examples.
  • Keeping people responsible for decisions on classifier flags.
  • Reviewing batches for repeated openers and predictable patterns.

Key moments

  1. 00:00Intro
  2. 00:47The gate stack
  3. 02:50Match the metric to the comparison
  4. 03:54Five gates, all tests green
  5. 07:06AI checking AI
  6. 10:46The set, not the item
  7. 13:35Verdicts
  8. 14:24Wrap up

Ready to move?

Tell us where your business is today. A written assessment lands in your inbox within two business days.

Talk to us

Transcript

Intro

Our plagiarism check once passed a page that was half copied. Three hundred of its six hundred words came word for word from a fifteen thousand word article. The check scored it 0.019 out of 1. Anything under 0.5 passed. And every unit test on that check was green.

The code was fine. It measured the wrong thing, perfectly. That's today's subject. Building quality gates for AI drafts is the easy half. Testing the gates before you trust them is the half almost everyone skips.

We'll build the gate stack, run the ninety second demo that changed how we measure copying, meet five gates that were wrong while every test passed, and then put an AI judge on trial.

The gate stack

First, the stack. Every draft passes these gates before it can be marked ready. Cheap, deterministic checks go first: facts against the grounding pack, copying against sources, duplicate phrases against your own pages, floors, opener variety, banned patterns and brief leaks. Only then does a small AI classifier look for what no rule can see.

Two of those deserve numbers. The duplicate gate breaks every page into eight-word phrases and rejects a draft that shares five or more with any page of the same type. Why five? Because after a cleanup, the cleanest pages in that corpus shared at most four. The threshold came from the data, not from a gut feeling.

The opener gate looks at the set, not the page. In one batch of directory drafts from a pipeline we built, 81 percent opened with the same sentence shape. Each draft was fine on its own. Together they read like a photocopier. Now no opener shape may cover more than a quarter of the set, and a draft that would push past that line goes back.

The fact check is plain code, not a model. It pulls every number and year out of the draft and compares them with the pack. The trick is context. A year only counts as a release date when a release verb sits right before it. Otherwise a sentence about a legend from two thousand years ago fails a perfectly good page. Every rule like that is a small guess about meaning, and guesses can be wrong.

Names get the same treatment as numbers. Every streaming service a ReelRadar draft mentions must exist in that page's pack, for that country. A draft that adds a service the pack never listed fails, even if the service really does carry the film. True but unchecked is still unchecked, and next month it's just untrue.

One rule for the whole stack. When a gate can't run, the draft is held, not published. A network error on the classifier is not a pass. If your pipeline treats a crashed check as a green light, you don't have a gate. You have decoration.

Match the metric to the comparison

Now the demo. There are two common ways to score copying. Jaccard similarity divides the phrases two texts share by all the distinct phrases in both texts together. Containment divides the shared phrases by the phrases in your draft only. Jaccard asks how alike two texts are. Containment asks how much of yours came from theirs.

Watch what length does. Our draft is six hundred words. The source is fifteen thousand. Copy half the draft from the source, and the shared phrases are a rounding error next to everything in that huge source. Jaccard reads 0.019 and waves it through. Containment reads 0.50, because half the draft is the source. Our containment gate rejects anything at 0.08 or above. Caught.

Jaccard isn't a bad metric. It's the right one when both texts are about the same length, which was its original job in our pipeline. The lesson is narrower and more useful: pick the metric for the shape of the comparison, not whichever function already sits in the file.

Five gates, all tests green

Now the harder lesson. In one working session on a pipeline we built, five gates turned out to be miscalibrated, and every one had green unit tests. The copying check was the first. Here are the other four.

Gate two was a naming rule: the English title must appear in the answer. We ran it over all 627 pages already in our store, and it condemned 132 pieces of good writing, including openers that hooked the reader with a character instead of the title. It would also have fought our own opener variety gate. Two gates, one tug of war.

Gate three was the fix for gate two. For one title it could never be satisfied, because the short name was contained in the long one. Our pipeline regenerates rejected drafts automatically, so that page would have been rewritten forever. A gate nobody can pass isn't a gate. It's an infinite loop with a budget.

Gate four checked internal links: at least three per page. It rejected a page about a character who appears in only one series. So the gate wasn't measuring links at all. It was measuring how long a show ran. Gate five, its fix, counted only published neighbours, so the same page passed or failed depending on the order the batch was saved.

The brief-leak check from last episode belongs in this stack too, in two layers. A rule searches every draft for your brief's own vocabulary. Then a classifier asks whether the text talks about the information it was given. The rule is cheap and exact. The question catches the paraphrases the rule misses.

So why did every test pass? Because a unit test encodes the same assumption as the gate. What caught all five was running each gate over the whole corpus and reading what it wrongly condemned. Then three more questions. Can it always be satisfied? Does the order matter? Does it fight another gate?

Then make the lesson permanent. When we fix a gate, the numbers from its corpus run go into the test suite. Anyone who loosens a threshold later has to argue with real data, not with the assumption that wrote the gate in the first place.

One more trap, from a financial-data site we run. Your stored pages can't show you wrongful rejections, because rejected drafts never get stored. A sentence splitter there broke on names with initials, the kind with a full stop after each letter. It quietly blocked 132 of 8,571 entities every night, while the stored output looked spotless.

So calibrate on everything the gate will ever see, not on what survived it. Feed it synthetic probes: every name, as the subject of a sentence and at the end of one. Count what it blocks, before and after every fix. The survivors will never tell you who didn't make it.

And strip the non-prose before a prose rule runs. On an education site we run, banning a marketing buzzword that's also a real finance term condemned 40 correct finance pages. A rule against spaced hyphens fired on a minus sign in an equation. Once we stripped the maths out first, the hyphen rule still caught 167 real cases and dropped only the 4 that were maths.

AI checking AI

Now the fun part: AI checking AI. Some defects have no pattern a rule can match. Is this paragraph filler? Is it giving financial advice the site must not give? Is it talking about its own instructions? For those, we use a small, cheap model as a classifier.

The key word is classifier. We never ask a model to rate a page from one to ten. Each gate is one narrow question, answered yes or no with a probability. Anthropic's evaluation guide says the same: clear rubrics, answers like correct or incorrect, and test reliability before you scale. As of October 2026 it lists its Haiku model for exactly this kind of high-volume classification. Our own numbers come from a dedicated small classifier model.

Here's one such gate on a financial-data site we run. Over all 5,622 stored paragraphs it flagged exactly one, and that one was a real defect. Of 24 violations we planted into real paragraphs, it caught all 24. On another site, it caught 12 of 14 planted tells of machine writing.

Calibrating one question takes an afternoon. Pull real paragraphs, label a sample by hand, then splice known violations into clean ones so you know exactly what should be caught. Run it, count the catches and the false alarms, and set the threshold where the two groups separate. Not at a nice round number.

The first wording of one question was a disaster. Asked whether a paragraph claimed a bank was failing, it flagged 52 paragraphs that only reported poor figures. We added one line: a poor figure alone is not enough. False alarms went to zero, and every planted case was still caught. When a wrong answer makes you explain what you meant, that explanation is the missing half of the question.

Now the limit. On a content site we run, we screened character facts for spoilers with the same kind of classifier. Precision was good. Then a person read every remaining value and found 52 more spoilers the model had scored as safe. So classifiers find, and people decide. Scores also wobble by about 0.05 between identical calls, so keep thresholds away from where real cases cluster.

And never let a deploy depend on a live classifier call. It's a network request to someone else's model, and on our side about one call in 5,600 timed out. Store the verdict when the draft is generated, keyed by a fingerprint of the text, and let the deploy read that. A stored verdict can't wobble, and it can't time out at midnight.

Where does a flag go? Into a queue a person reads. When they confirm it, the decision goes into a curated file the pipeline reads on every run, so it sticks. The classifier is the finder, the file is the memory, and the person in the middle stays.

There's a deeper reason for caution. Research on AI judges has documented position bias, verbosity bias and self-enhancement: judges favouring answers by where they sit, by length, and by whether they wrote them. A 2025 study went further and found language models prefer text written by language models. An AI grading AI writing starts with a thumb on the scale.

Here's a receipt you can rebuild at home. In Claude Code, write a three-question classifier gate and mix 40 good drafts with 10 you broke on purpose. Run it, then open two lists: the planted defects it missed, and the good drafts it condemned. Reword the weakest question and run again. Those two lists are the whole exercise.

The set, not the item

One more failure mode, and no single-draft gate can see it. Parallel generation converges. We generated fifteen portraits in separate calls, each with a menu of clothing options. All fifteen picked the same one. Fifteen good images of what looked like one person with a very consistent wardrobe.

Each call sees only its own prompt, so it picks the most likely answer, and they all pick the same one. A menu in a prompt is a request for the most popular choice. The fix: assign the varying part in configuration, give each item its own value, and review the set as a set.

Names did the same thing. Asked separately for plausible names, the calls produced two Whitakers and three Mercers. Each name was fine on its own. Only the list looked like a family reunion.

Text does it too. Generate ten intros in parallel from one brief and lay them side by side, then count the shared openers. Our duplicate gate once rejected a draft for colliding with another one generated minutes earlier, in the same batch, from the same brief. The gate did its job. The batch had quietly cloned itself.

Reviewing a set needs no special tools. Put every opening sentence in one file, sort it alphabetically, and read down the list. Repeats you'd never notice page by page line up next to each other in seconds.

And a warning about one-sided gates. In a quiz-generation pipeline we tested, all 30 answer keys in the first batch were option A. Always pick A, get full marks. We fixed position, and the keys leaked through length instead. So we added a gate: the key must not be the longest option. The generator's reply was to make the key the shortest option 51 percent of the time, against 26 percent by chance.

Fixing one cue tends to create the next. When a gate removed a giveaway phrase from the wrong options, the generator found another phrase only the wrong options shared. What finally caught it was a scan for any content word that appears three or more times on a page, but only in keys or only in wrong options. Once a reviewer names the same cue twice, it becomes a mechanical test.

What worked was simulating a test-wise student. Always pick the longest. Always pick the shortest. Pick the odd one out. Score every strategy against chance. If any strategy beats chance, the set leaks, however innocent each question looks.

Notice the pattern across this whole chapter. Every gate we fixed was a gate that looked at one item at a time, while the problem lived in the set: the openers, the portraits, the names, the answer keys. So set checks belong on the whole batch, after the item gates and before anything is marked ready.

Verdicts

Two verdicts. Claim one: AI can grade its own writing.

Partly. A separate, narrow question, calibrated on labelled examples, finds real defects cheaply. Ours did. Ask a model for a general grade of its own output, though, and it brings documented biases toward position, length and its own style. Verdict: contested. Let it find, and keep a person deciding.

Claim two: unit tests prove a gate works. We had five gates with green tests that were wrong in one session, and a sentence splitter that passed its tests while blocking 132 entities every night. Tests share the gate's assumptions. Verdict: placebo. The corpus and the full input population are the real test.

Wrap up

The episode on one screen. Cheap rules first, a classifier last, and every metric matched to its comparison. Run every new gate over the whole corpus and the input population, and read what it wrongly condemns. Classifiers find, people decide. And review the set, not just the items.

The gate checklist and a classifier gate starter are free on the episode page at irongoo.com. Next episode: programmatic SEO, and a template that passed every quality check we had, then met Google's opinion of it.

Free ebook

Put your next steps in order

Build on what you have just read with a free ebook on semantic SEO and AI visibility. Get worked examples, decision rules, checklists and a do-this-week action in every chapter, plus a six-week plan for your site.

By signing up and confirming your address, you consent to receive the free ebook plus one email every two weeks with 3 or 4 new Iron Goo videos, guides and articles, and nothing else; unsubscribe any time with one click.