Fidelity drift

The pattern

Batch blindness is about what happens across a set of outputs. Fidelity drift is about what happens inside a single one, and it surfaced from the same test, at a different stage of the pipeline.

The batch image-generation run used real product photography as reference input, then let an image model synthesise the final lifestyle scene rather than compositing the original product pixels directly into it. That's a reasonable, faster approach, and for most of the 51 images it held up: colour, shape and general product character carried through recognisably.

But synthesis isn't reproduction. The model is regenerating the product's appearance from what it inferred about the reference image, not placing a verified copy of it into a new scene. Everywhere the products in shot had fine print, distinctive packaging detail, or a licensed design on them, that's exactly where the risk concentrated: the broad shape survives, the fine detail doesn't reliably.

Why this is a different failure to batch blindness

Batch blindness is a page-level problem: individually correct outputs that only reveal a fault when viewed as a set. Fidelity drift is the opposite shape: it's a fault that can exist inside one image in isolation, invisible unless someone is specifically checking that image's product detail against the real product it's meant to represent.

That distinction matters for how each gets caught. Batch blindness needs a rule about the set: a specified distribution, checked once, applied across the batch. Fidelity drift needs a rule about acceptable fidelity per item: a threshold decided in advance for what level of product-detail accuracy a given use case actually requires, checked per image, not per batch.

Where the threshold actually sits

Not every use case needs the same fidelity. A category tile meant to communicate "this is broadly what you'll find in this section" can tolerate a synthesised scene where the product's general shape and colour read correctly, even if a logo has drifted slightly. Product advertising, or anything where a customer is being shown the specific item they're about to buy, can't tolerate that same drift: a customer choosing between two products based on packaging they can't quite verify is a different kind of risk to a category page that's setting a mood.

The fix isn't "always use full compositing" or "synthesis is unsafe." It's deciding, before the batch runs, which side of that line each use case sits on, and for anything that needs guaranteed fidelity, using the slower approach: generate the lifestyle setting first, then mask and composite the real product photography into it, rather than letting the model regenerate the product itself.

That's the same shape of fix as Batch blindness: not a better prompt, not a smarter model, a decision made explicit before generation instead of discovered on review afterwards.

A second confirmation, from writing the rule down

The clearest evidence for this pattern didn't come from the original test. It came afterwards, from writing the standard down in plain terms and checking the test against it.

A separate team, working through the same kind of batch process on a live product catalogue, had an existing internal standard: categories should always use real products, never an inferred or generated likeness standing in for the real thing. Stated that plainly, it's an easy rule to agree with. Checked against a completed batch that had already shipped and looked correct on review, the batch didn't actually meet it: the images had been generated from real product references, not composited from the real product photography itself. Nothing about the finished images looked wrong. The gap only became visible once the standard existed in writing and someone checked the process against it, rather than the output.

That's the whole pattern in miniature. Fidelity drift isn't usually caught by looking harder at the image. It's caught by writing the standard down first, then checking the process against it, because a synthesised image can pass every visual check and still not be what the standard actually requires.

Where this sits

Surfaced from the same self-run test as Batch blindness: real products, real category pages, deliberately thin initial brief. Not a controlled demo built to prove the point; a real production task that happened to produce two distinct, nameable failure patterns rather than one.