The short version
- When a product image looks fake, the usual root cause is that nobody decided what has to stay untouched and what is free to change. The interface, the logo, the price all get reinterpreted by the model.
- If something has to be pixel-identical, use an explicit mask or composite it in afterwards. If you're generating from a reference image, set preservation constraints, pick the right intensity, and check the output item by item.
- SaaS screenshots are the worst case: dense, full of text, and impossible to fudge. Which also makes them the clearest argument for building the process this way.
AI product images look fake because nobody told the model which parts have to stay untouched, so it reinterprets the interface, the logo, and the price. If a detail has to be pixel-exact, use an explicit mask or composite the product back in afterwards. If you generate from a reference image, set preservation constraints and check the output item by item.
Here's one from our own work. Early on we were making ad images for a dashboard SaaS using pure text-to-image, with a very detailed prompt: style, palette, what the interface should look like. The first render was impressive from across the room. Up close, the chart axes were nonsense, a button read "Sbmit," and where the user avatar belonged there was a smear.
The model wasn't slacking. We had asked the wrong question from the start. We told an AI to draw an interface it had never seen, so it invented one. This is how to fix that at the root.
Diagnose it first: the problem isn't bad drawing, it's what you asked for
Pull "the product doesn't look right" apart and you find two unrelated problems stuck together:
- Things that are simply wrong: the interface, the text, the logo, the shape of the product. These are facts. They're either right or wrong, and "attractive" never enters into it. Garbled type, misspellings, warped geometry all live here.
- Things that are merely unappealing: background, lighting, mood, setting. No single correct answer exists, and this is where a model earns its keep.
Almost every serious blowup is the first kind. And you don't fix the first kind by switching to a stronger model or writing a longer prompt. As long as your product content passes through a generative model, it can be rewritten. When you need 100% fidelity, the original pixels have to reach the final image directly, through a mask or a composite.
Why SaaS screenshots break the worst
Physical products are forgiving. A bottle, a sneaker: the model has seen thousands, so a redraw lands close enough. A SaaS screenshot is a different animal. It's the blind spot of text-to-image, for three reasons:
- Text density is brutal. One admin screen can carry dozens of fields, buttons, and menu items. Every character is another chance to be wrong. The odds of every one of them landing right are dismal. This failure mode has been studied directly: research into why image models can't spell traces it to how text is encoded before the model ever draws, which is not something a longer prompt reaches.
- The information is yours alone. What your interface looks like is not in the training data. The model can only guess at "generic dashboard," and a generic dashboard is not your product.
- One small mistake gives it away. Blur the background on a product photo and the flaws disappear. A UI screenshot is flat and sharp, and a misspelled label is the first thing a reader notices.
So if your product's main visual is an interface (SaaS, tools, apps), you can drop pure text-to-image entirely. That's no knock on the models. It's the wrong approach for the job.
Two approaches: keep the pixels, or constrain the reference
There are broadly two ways to get product truth into an ad image.
Keep the pixels. Use a mask, or composite the real asset in after generation, so the original lands in the final image untouched. This is what you want when a price, an interface, or a logo has to match exactly. Building the mask no longer means tracing by hand — segmentation models like Segment Anything will cut the product region out of a screenshot for you.
Constrain the reference. Feed the original in as a reference and hold on to the layout, the creative DNA, or just the product facts, depending on how much room you want. You trade some fidelity for far more freedom in composition and localization.
LinkBloom's Image Fission takes the second route, at three intensities. Light keeps the layout and hero visual, medium keeps the creative DNA, heavy keeps only the product facts and the core claim. It isn't a pixel-freeze tool. List the critical UI, logos, prices, and numbers as must-preserve items, then check each one against the output.
Internally we draw a clear line between what gets locked and what gets generated:
| Element | How to handle it | Why |
|---|---|---|
| UI screenshot | Preserve at high priority; composite it in when it has to be exact | It's a fact, and mistakes here are obvious |
| Product logo | Brand anchor; composite when exactness matters | Brand asset, never distorted |
| Prices and numbers | Constrain explicitly, then check digit by digit | One wrong digit is an incident, not a typo |
| Headlines and value-prop copy | Visual review after generation, plus a human read | Text has to be exact |
| Background and setting | Let the model run | There's no single right answer |
| Light, shadow, material | Let the model run | This is what image models are actually good at |
The line that table draws comes down to one question: can this be wrong? Anything that turns into an incident when it's wrong gets stronger preservation, and a pixel composite when preservation isn't enough. Scenes and atmosphere, where variation is the whole point, are where a model should have room.
One step upstream, that same rule (product facts don't get rewritten on a whim) becomes the Evidence Graph: every creative angle ties back to a real product fact, a source, and a confidence level, so unsupported claims are far less likely to reach the image. The industry's other answer to the same worry is provenance: the C2PA specification writes what edited an image, and with what tool, into the file's own credentials. One records where a claim came from, the other records what touched the pixels. How AI ad creative generation actually works goes into that side in more depth.
When an image comes back wrong, debug in this order
If you already have a bad image in front of you, don't go shopping for a different tool. Walk this list and you'll usually find it:
- Start here: is the product composited from the original, or generated from a reference? The first keeps original pixels; the second gives the model room to reconstruct. They fail in completely different ways, so answer this before anything else.
- Is the source asset sharp enough? Composite or reference, a low-res input caps the result. For UI screenshots we work to 1080px wide as a minimum — that's our own internal baseline, not a platform requirement.
- Did any text pass through the model? Zoom in on headlines, buttons, prices, brand names. If the model touched them, read every character. When you need exact type, move it to a post-production text layer instead.
- Does the setting fit the product? Sometimes the product is fine and the model has dropped it somewhere that makes no sense, like a B2B admin console against a theme-park background. That's an angle problem, not a fidelity problem. Rewrite the scene description.
- Have you looked at the quality status? LinkBloom reviews every output across 7 dimensions, and the "product truth" dimension specifically checks facts and how the product is represented, flagging the image as auto-approved, needs review, or rejected. Treat the status as a risk signal, not a replacement for your own eyes.
A worked example: one SaaS screenshot ad, done right
A real one from our work. A multi-account management tool wanted an ad image that read "professional, credible, technical," with its console as the hero visual.
The version that failed. We described the interface in the prompt and let the model draw it. The account list came back as gibberish and the icons were off their grid.
The version that had to be pixel-exact. We composited the real console screenshot into the center of the frame, set the headline ("Every account, one dashboard") as its own text layer above it, and let the AI generate the background scene only. Product accuracy and typographic accuracy became the compositing pipeline's job; the model handled the mood.
Both took roughly the same amount of time. The results weren't close. The difference wasn't the model. It was what touched the product.
Want to try it yourself: signing up gets you 100 one-time credits, and an image costs 10. Start free and run one of your own screenshots through it. Nothing makes the point faster.
FAQ
Will a bigger, more expensive text-to-image model fix the garbled output?
It treats the symptom. A stronger model may lower the error rate, but as long as the product is still being redrawn by a model, errors stay possible. Critical content needs either tighter preservation plus a manual check, or a mask and composite instead.
I only have one low-res product image. Now what?
Fix the resolution before you think about generation. How sharp the product looks depends first on the input you feed in. Anything under 1080px wide — our internal working floor — turns mushy when it's scaled up. Re-export at full resolution if you can. If you truly can't, at least flag the low-res input as a review risk.
If the product is frozen, what is the AI still doing for me?
Plenty: setting, mood, lighting, channel sizes, language versions. The stronger the preservation, the less room there is to vary. When you want bolder creative, relax the layout constraints and tighten the check on product facts and copy to compensate.