Checking documents with AI: a checklist of errors it finds well

An AI for checking documents is useful as a second reader: it quickly finds contradictions between sections, missed mandatory clauses and broken references to clauses. But not everything should go to a model: checksums and arithmetic are more reliable in code, and the legal and factual force of a document is for a human to judge. Below is a checklist in three groups (code, model, human), a working Python example and a cost estimate. Using AI to correct and edit documents follows the same principle: first collect findings, then you decide which to accept.

Three groups of checks

Split the checks by who handles them most reliably.

This table is the main point of the article: the model does not replace the other groups, it covers the middle one.

Checklist: what to give the model

These items are easy to state in words and hard to catch with regular expressions. Test on your own documents how accurately the model finds them:

1. Contradictions between sections. One place says payment within 5 days, another says 10.
2. Inconsistent data. Different spellings of a party's name, different amounts in the text and the appendix.
3. Dangling references. "See clause 4.3" when there is no such clause; "Appendix 2" that is not in the document.
4. Missing mandatory sections relative to a list you provide (subject, deadlines, payment procedure, liability, details).
5. Undefined terms. A capitalized term is used but never defined.
6. Amount in figures versus in words. The model may notice a mismatch, but still re-check the final arithmetic with code.
7. Typos and style. A uniform form of address, repetition, ambiguous wording.
8. Numbering and formatting. Skipped numbers, mixed date formats.

Checklist: what to leave to code

If a check is algorithmic, don't spend tokens and don't risk a model error. Example: the check digit of a ten-digit Russian tax ID (INN).

def inn10_valid(inn: str) -> bool:
    if len(inn) != 10 or not inn.isdigit():
        return False
    weights = [2, 4, 10, 3, 5, 9, 4, 6, 8]
    check = sum(int(d) * w for d, w in zip(inn, weights)) % 11 % 10
    return check == int(inn[9])

print(inn10_valid("7707083893"))  # True
print(inn10_valid("7707083894"))  # False

The same goes for dates (through datetime), amounts (add up the items and compare with the total) and mandatory fields (pattern search). For personal tax IDs, company registration numbers and other details the algorithm is different; check it against the official description.

Checklist: what stays with a human

• Whether a term complies with the law and serves your interests.
• Whether the facts match reality and the primary documents.
• Who signs and whether they have the authority.
• Whether the text contains anything that should not be there under your industry practice.
• The final decision to accept or reject the model's suggestion.

Example: a semantic check through the API

We ask the model to return findings as a JSON list with a quotation, so a human can find the place quickly. An OpenAI-format request; details are in the chat completions documentation↗:

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.zukko.pro/v1", api_key="fetch_your_key")

CHECKLIST = """1. Contradictions between sections (deadlines, amounts, parties).
2. References to clauses and appendices that are not in the document.
3. Missing sections: subject, deadlines, payment procedure, liability, details.
4. Terms used without a definition.
5. Different spellings of the same name or title."""

SYSTEM = f"""You check a document against a list. Do not fix or invent anything.
Check only the items of the list:
{CHECKLIST}

Note three techniques: the list of checks is explicit (the model does not wander through the text), the quotation lets you find the place instantly, and "confidence" helps prioritize. If you need strictly valid JSON, see structured JSON output↗.

How not to miss the model's own errors

A model errs in both directions: it invents a finding that does not exist and misses a real one. What to do:

• Ask for a quotation and verify that it appears in the text: if item["quote"] not in text, and mark such a finding as doubtful.
• For important documents, run the check twice on different models and compare the reports. Look at the differences by eye.
• Test on a document with pre-planted errors: swap a deadline, delete a clause, and see what is found. That tells you what to expect from the model on your own texts.
• Don't cut very long documents arbitrarily: models in the catalog have a 1M-token context, so a document usually fits whole, and contradictions between distant sections are visible only in the full text. If a document is still longer, see summarizing long documents↗.

What a check costs

Prices as of October 18, 2026, $ per 1M tokens (input / output): gpt-6.1-sol 0.27 / 1.32, deepseek-v4.1-flash 0.013 / 0.038. Example: a contract of about 12,000 tokens plus the checklist, and a 1,000-token report.

• gpt-6.1-sol: 12,000 × 0.27 + 1,000 × 1.32 = 3,240 + 1,320 = 4,560, i.e. $0.00456
• deepseek-v4.1-flash: 12,000 × 0.013 + 1,000 × 0.038 = 156 + 38 = 194, i.e. $0.000194

(divide by 1,000,000). For a hundred documents a month that is about $0.46 and $0.02 respectively (100 × 0.00456 and 100 × 0.000194). The cheaper model may miss more, so compare reports on your own documents first. Fresh prices are always in the GET https://api.zukko.pro/v1/models response. If you need to compare a document with its previous version, the contract analysis guide↗ will help.

To run the example, create a key in the dashboard↗ and run the script on an anonymized document.

FAQ

Can AI fully replace proofreading of documents?

No. It covers semantic checks and saves time, but formal checks are better done in code and substantive ones stay with a human.

Can I ask the model to fix the document right away?

You can, but first get the list of findings and decide on each one. Automatic rewriting of the whole text can quietly change the meaning of terms.

Which documents can I send for checking?

Any that you are entitled to pass to an external service. It is better to anonymize personal data and trade secrets or not send them; that is your organization's decision.

How do I know the model did not find everything?

Run a test on a document with pre-planted errors and count the share found. One such test tells you more than any general claim about model quality.