AI Brochures Can Hallucinate Your Client's Google Rating

When Every Fact Becomes a Pixel

There is a moment, the first time you build a brochure entirely from AI-generated images, when it feels like cheating. Cover page, services spread, pricing table, the trust panel with the star rating -- all of it produced as PNGs and assembled into a print-ready PDF. No fonts to license. No layout tool fighting you over kerning. No designer round-trip. The output is genuinely beautiful, and you shipped it in an afternoon.

Then you notice the cost of that speed: every fact in the document is a pixel. The client's phone number is not text -- it is paint. Their five-year-anniversary badge is not a data field -- it is rendered light. And their Google rating, sitting proudly on the trust page, is whatever number the image model decided to draw.

This is the trade nobody mentions in the demo. Image-native generation removes your entire editing layer. A normal brochure -- InDesign, HTML, even a Word doc -- keeps text as text, so a wrong figure is a thirty-second fix. An image-native brochure keeps text as image, so a wrong figure means regenerating the whole page and hoping the model reproduces everything else identically. The flexibility you gained at creation becomes rigidity at correction.

Most of the time this is fine, because most of the facts are correct. The danger is the one that is not -- and the reason it is dangerous is that you will not find it by reading the file. You will find it when the client does.

The Moment It Surfaces: "Page 9 Says 4.5 Stars"

Here is how it actually plays out. The brochure is delivered. The client opens it, flips to the trust page, and sends a one-line message: "Page 9 says 4.5 stars -- we're 4.9." Small thing. You open the file expecting to click into a text field and change one digit.

There is no text field. The rating is drawn directly into the image at generation time, anti-aliased into the background gradient, sitting under a halftone of stars that are also painted. You cannot select it. You cannot find-and-replace it. The only fix is to regenerate that page -- which means re-running the prompt, getting a slightly different layout, and re-checking that nothing else shifted in the process.

A wrong rating in a trust panel is not a cosmetic bug. The entire purpose of that page is credibility, and you have just handed the client a credibility asset that lies about them in their favour -- which, if a customer ever cross-checks it against the real Google listing, reads as either incompetence or fabrication. The under-statement direction (4.9 shown as 4.5) is the lucky case. The over-statement direction is a compliance problem.

The instinct is to blame the model: the AI made up a number. That instinct is wrong, and chasing it leads you to the wrong fix. The model did exactly what it was built to do.

Why the Model Invents a Rating

An image model asked to produce a "trust signals page for a pest control business" has to draw a rating. That is part of the visual genre -- trust pages have star ratings, the way invoices have totals. So the model produces one. The only question is where the number comes from, and the answer is: whatever signal is most plausible in context.

If your prompt supplied the authoritative value -- "Google rating: 4.9 from 212 reviews" -- the model will usually honour it. If your prompt did not, the model fills the gap from somewhere else: an associated brand asset it was shown, a half-remembered figure from the surrounding text, or its own training-data prior about what rating a business of that type "tends" to have. None of those sources are your client's actual rating. They are plausible-looking defaults, and plausible is exactly what a hallucination is.

So the root cause is not a flawed model. It is a gap in the generation prompt. The model was never given the canonical fact, so it invented a plausible one -- and because the output is an image, the invention is indistinguishable from the truth at a glance. This reframing matters because it tells you where the fix lives: not in a better model or a "please do not hallucinate" instruction, but in the inputs you feed every page that displays a fact.

That gives you two concrete defences, and you want both.

The Comms Data Sheet: One Source of Canonical Facts

The first defence is structural. Maintain a single comms data sheet for every client -- one file that holds the canonical facts the brochure will display: name, address, phone (NAP), Google rating and review count, licence or certification numbers, service area, warranty terms, pricing. This is the same discipline that makes AI-citation infrastructure trustworthy: a machine-readable source of truth that downstream generation reads from instead of guessing.

Then make that sheet a required input to every page prompt that renders a fact. Not "available if needed" -- required. The prompt for the trust page should literally interpolate rating: 4.9, reviews: 212 from the sheet, so the model is never in the position of having to invent it. If a fact is not in the sheet, that page does not get generated until it is. The sheet becomes the gate.

This single change closes most of the hole, because most hallucinations are gap-fills. Remove the gap and the model has nothing to fabricate. It also gives you a second benefit: when the client's rating changes from 4.9 to 4.8 next quarter, you update one field in one file and every future asset inherits the correct number. The canonical sheet is the same idea behind a compounding knowledge base -- write the fact once, in one trusted place, and let everything downstream read from it.

A comms data sheet does not eliminate the risk on its own, though. Prompts can still be malformed, fields can be missed, and a model can occasionally ignore a supplied value under a busy prompt. So you also need a check at the other end.

The Pre-Delivery Fact Audit

The second defence is procedural: before any image-native brochure goes to the client, audit every page against a fact checklist. Walk the document page by page and, for each, ask one question -- does this page display a fact, and if so, does the fact match the source?

The non-negotiable five are the ones with consequences if wrong: business name, Google rating, address, licence or certification number, and pricing. Any of those rendered as text-in-image needs a source citation in your generation log -- a note that says "rating 4.9 came from the comms sheet, line 7," not "looked about right." If you cannot point to the source, treat the figure as unverified and regenerate the page with the correct value interpolated.

This sounds heavy. It takes about five minutes for a ten-page brochure once you have the checklist, and it is the single highest-leverage five minutes in the whole workflow, because it is the only step that catches a hallucinated fact before the client does. The cost of skipping it is not five minutes saved -- it is a credibility incident, a regeneration cycle, and a client who now reads every future page more suspiciously.

Bake the audit into the definition of done. The brochure is not finished when the PDF assembles cleanly. It is finished when every fact-bearing page has been checked against the source and logged.

The Hybrid Fix: Image Layout, Real HTML Text

There is a more durable answer for the highest-stakes facts, and it sidesteps the whole problem. Instead of baking the rating into the image, generate the visual layout as an image -- the gradient, the star halo, the card framing -- but leave a clean region where the number goes, and overlay the verified fact as real HTML text positioned over the asset.

Now the rating is editable. Change one string and it updates everywhere, no regeneration. It is also accurate by construction, because the text comes straight from your comms sheet rather than from the model's imagination. And -- the part people forget -- a screen reader can actually read it. A number painted into a PNG is invisible to assistive technology and to any machine trying to parse the page; a real text node is both. For anything that doubles as web content, that is the difference between an asset that is AI-citation-ready and one that is a flat picture.

The trade is that you reintroduce a small amount of layout work -- positioning the overlay, matching the font, handling responsive reflow. That is a fair price for the facts that carry legal or reputational weight. The pragmatic split: use pure image generation for decorative and structural elements where a wrong pixel costs nothing, and use the hybrid overlay for the five non-negotiable facts where a wrong pixel costs trust. You get the design speed of image generation where it is safe and the editability of real text where it matters.

Run the Checklist Before Your Next Review

Image-native brochures are a genuine leap -- they collapse a multi-day design pipeline into an afternoon and produce work that looks like a studio made it. The catch is that they convert every fact into a pixel, and pixels cannot be hallucination-checked the way text can. The model is not broken; your prompt simply left a gap, and the model filled it with something plausible.

The defences stack. Feed a canonical comms data sheet into every fact-bearing prompt so the model never has to guess. Audit every page against the five non-negotiable facts before delivery. And for the facts that carry real weight, overlay verified HTML text on the generated layout so the number stays editable, accurate, and readable by machines. None of these is expensive. All of them are cheaper than the message that starts with "page 9 says."

If you are shipping image-native brochures today without a fact-audit step, assume at least one page already contains a number the model invented. Do not wait for the client to find it -- run the checklist before your next review. If you want help building this kind of AI-assisted production pipeline with the guardrails baked in, that is exactly the work we do in our AI development services.