Quick answer: Here's a quick experiment you can run on any AI presentation tool tomorrow. Paste a short product brief — the deliberately boring kind, with real numbers, dates, and a couple of careful qualifications — and ask for a deck. Then read the generated slides against the brief with a highlighter. In most tools you'll find: a percentage that isn't in the source, a launch date shifted by a month, a benchmark number quietly rounded upward, the qualification that contained the caveat deleted, and a punchy quote nobody said.

None of this is malice. It's the default behavior of a model trained to produce fluent, complete-looking output: where the source has a gap, the draft fills it with a statistically plausible shape. The risk is asymmetric. If an AI image tool makes your gradient look slightly off, you fix it. If an AI deck invents a metric in a pitch or a sales presentation, that's the moment you lose trust — or worse, publish a false claim.

The design question in the AI era is therefore not just "can it generate?" but "does it know what it may not say?" At Neatico we treat the source text as evidence and the model as a drafter whose work is audited against it. This is the audit pipeline.

The content contract is where the truth lives

The LLM never produces a design. It produces a structured content plan — pages, typed blocks, and on every claim, an optional evidence field referencing the source segment it came from. That JSON is then validated by a deterministic pipeline before anything renders. A claim that can't pass the contract doesn't reach the canvas, and the model is asked to repair its own draft, not silently allowed to proceed.

The validators are unglamorous and deliberately specific. They check the things people actually hallucinate:

  • Quotations must preserve the supplied wording. A quote block that doesn't appear verbatim in the source is rejected. A model cannot paraphrase a sentence and put quotation marks around it.
  • Percentages and headline values must exist in the source. A stat or metric block showing a number that never appears in the pasted material is rejected, even if the number is "close."
  • Chart values must be supplied numbers. A chart can't invent a bar. Every series value has to be traceable to the source.
  • Dates must match. Calendar dates in the output are checked against dates in the source; an October event can't become a September event.
  • Quantified claims must be grounded. Numbers with units (currency, hours, people, durations) that aren't present in the source are rejected, and superlative/positive claims are only allowed when the source actually supports them.
  • Qualifications are non-negotiable. If the source says "faster in our benchmarks" or "available on desktop in November," the limiting clause is kept verbatim. The draft can't turn a conditional claim into an absolute one.
  • The source language is preserved. If the source is primarily Chinese, the audience-facing copy must be Chinese; the system won't translate a non-English brief to English just because English is the default, and it doesn't force English-font fallbacks on non-English text.

Coverage: what the draft didn't say

Fabrication is one failure mode; omission is the other. A model that wants its output to be clean and on-brand will quietly drop the awkward, dense, or inconvenient parts of your source — which is precisely where technical and business truth lives.

So the coverage check runs in the opposite direction. The source is segmented, and every substantive text segment (the threshold is a short paragraph, to ignore boilerplate) must be cited by an evidence reference somewhere in the plan. If the model built a beautiful pitch deck entirely out of image blocks and skipped the source's actual text, the plan is rejected. A page that exists only as a photo with no content is rejected too — unless you actually uploaded an image, in which case it's your image, not an invented one.

There's also a narrative-sequence check with a surprisingly opinionated rule: if the source describes parallel responsibilities (who does what in parallel), the output must render that as cards or columns. It cannot convert a parallel structure into a fake sequential story, because sequential wording ("first A, then B") asserts a causal order that doesn't exist.

Density: the social-media check

For social campaigns, the validation also guards against the universal AI-card habit: cramming a poster with text. The density rules are explicit — a headline must fit within a character budget, a benefit list has at most three entries, and detailed facts and qualifications must move to the caption or additional carousel pages rather than be deleted. The rule is important: the model isn't allowed to pass a density check by dropping facts. It has to move them somewhere the format supports.

Which is why every social page also requires a caption, and the caption is validated against the same language and fact rules.

Repair is bounded, page-level, and keeps the evidence

A validator that only rejects is a frustrated user. When a plan fails, the pipeline repairs it:

  • The model is sent back the exact failing object, the specific error, the field path, and the rejected claim — and told to correct it using only supplied source IDs. It isn't asked to "try again" from scratch.
  • It gets up to three attempts to repair the whole plan.
  • If a single page fails, the repair narrows to that page: the other pages are retained as-is, and the model returns only the corrected page. One hallucinated chart doesn't burn the entire deck.
  • Repair instructions are explicit about the easy cheat — the model may not delete non-code content to dodge validation, and if a caption is in the wrong language, it must translate it rather than remove the asset.

The goal of the loop is that when a deck finally renders, it has passed the checks, not just run out of time.

Why this is a product philosophy, not a feature

The easy way to build an AI design tool is to maximize the rate at which the spinner returns something. Fluent output has a high first-glance success rate, and most users won't catch an invented number on a pass they make at midnight. The hard way is to treat every generation as a document with a source of truth, and accept that some drafts need to be repaired — sometimes more than once — before they're shown.

We chose the hard way because the people who benefit most from AI design are exactly the people who can't afford false claims: founders putting numbers in a pitch, marketers adapting a product brief, sellers generating a customer-facing deck, and a single developer reusing a launch description across eight social assets. For them, a polished slide that says something untrue is strictly worse than a blank page.

The model remains the best part of the system — it's fast, fluent, and tireless at restructuring. But it's not the authority. The source is the authority, the validator is the gate, and the model is a drafter whose job it is to obey both.

If you're evaluating AI tools for work that contains facts, don't just ask whether the output looks good. Ask whether the tool can tell you where each claim came from — and what it does when it can't. Feed Neatico a real, numbers-heavy brief and see what it refuses to say.

Related: Why the AI never touches a pixel coordinate · The complete Product Hunt launch asset checklist