Tooling

An AI output checker is judged by what it refuses to claim.

Every checker produces a verdict. The useful question is whether the verdict can be inspected: which rule fired, how bad it is, what ran, and what the tool never looked at.

Three things an output checker is not

It is not a detector. A checker that scores text for being AI-written is answering an authorship question, and answering it badly, because the signals it relies on are style, not provenance.

It is not a plagiarism check either. Similarity search compares your text to a corpus; it says nothing about whether the claim in paragraph two is true, whether the code executes, or whether the file kept its metadata.

It is also not a grader of quality. Quality includes fitness for a purpose, and purpose lives outside the document. A checker can only report defects against rules it was given.

The four families of check worth having

Output checks fall into groups that fail in different ways, and a tool that only covers one group will feel useful while missing whole categories.

  • Pattern checks: credentials, unsafe constructs, placeholders, debug residue, tell-list phrasing.
  • Structural checks: code that does not parse, headings that skip a rank, CSV rows with the wrong width, JSON that fails to load.
  • Claim checks: statistics without a visible source, absolute claims, dates that disagree with each other.
  • Metadata checks: images stripped of provenance, generator tags, file weight and dimensions against spec.

Test it with a seeded file, not a demo

Before you trust a checker, build a file containing defects you planted on purpose: one plausible key, one eval, one empty catch, one invented statistic, one unfinished placeholder, one heading that skips a level. Run it and count what comes back.

Then run it twice. A deterministic checker returns the same findings and the same score, which is the property that makes a report citable. A model-judged one drifts, and the drift is the earliest sign that the result is an opinion.

Finally, feed it a clean, deliberately plain paragraph and see whether it invents findings. A tool with no false-positive discipline will always look thorough, because it always finds something.

Coverage has to be printed

A score with no coverage statement is a guess wearing a suit. The report should say how many checks ran, what types of input they apply to, and where truncation occurred when a document exceeded the input limit.

That sentence is what keeps a green result honest. Zero findings across fourteen checks on a fragment is not the same claim as zero findings across forty checks on a full file, and the reader cannot tell the difference unless the tool tells them.

The same logic applies to images. A checker can report that provenance metadata is absent, present or damaged. It cannot validate a signature chain against a trust list, and it should say so instead of implying verification.

Weighting, and the false-positive tax

Severity weighting exists so a single credential finding cannot be averaged away by nine cosmetic notes. A checker without weighting produces scores that look stable and mean nothing.

The other side of the ledger is false positives, which are taxed in human attention rather than money. One rule that fires on legitimate code teaches people to skim, and a skimmed report is worse than no report because it creates the appearance of review.

Sooner or later you will disagree with a rule. A good checker makes that productive: the finding names the pattern, you decide it is acceptable in a fixture, and you note it. The tool has then done its job by starting an argument with a location.

Where a checker stops and a person starts

No output checker can tell you whether the argument holds, whether the audience will read a claim as a promise, or whether a senior engineer would merge the change. Those are judgement, and judgement needs an owner with a name.

The handover should be cheap. A report that travels with the review request means the specialist starts from findings rather than from a blank page, and the two artefacts then describe different things: absence of known defects, and an attributed decision about fitness.

That pairing is the only version of automated QA that holds up under scrutiny, because each half states exactly what it proves.

What this covers

  • Named rules

    Every finding points at a rule you can read and dispute.

  • Severity, not just counts

    Weighting keeps a critical finding from being averaged away.

  • Printed coverage

    The report says how many checks ran and what input they applied to.

  • Same result twice

    Re-running the same text reproduces the findings and the score.

  • Stated limits

    The tool says what it cannot see rather than implying completeness.

Questions this page usually raises

Can a checker tell whether text was written by AI?
Not reliably. Style signals shift with editing and prompting, and detectors disagree with each other. Provenance is a metadata question, and most pipelines strip the answer before the file reaches you.
What should a report contain at minimum?
The rules that fired, a severity per finding, the text that triggered it, the number of checks run, and any truncation. A score on its own is not a report.
How do I compare two tools fairly?
Run both on the same seeded file with planted defects, then on the same clean file. Count true findings, missed findings and invented ones. The third number is the one vendors omit.
Does an output checker replace code review?
No. It replaces the mechanical pass that code review spends its first ten minutes on, and it lets the reviewer spend their attention on design, dependency truth and risk.
Do these checks need to upload my file?
Ours run on your device. The rule engine executes in the browser against pasted text or a locally decoded image, so nothing is transmitted during a check.

AI output checker

Run the checks, then decide who has to sign it.

The automated pass is free, needs no account and uploads nothing. Escalate to a named reviewer only where being wrong is expensive.