If you have ever built a data pipeline where each step consumes the previous step's output, you already know the failure mode: an error introduced at step two arrives at step five looking exactly like a legitimate value. Downstream, both look like ordinary values of the same type.
Image generation pipelines behave the same way, and I measured it.
The setup
The subject is one drawing of an ice sculptor beside a block of ice with a thermos frozen inside it. Four rendering stages, run on Tsubaki.3 in PixAI:
line art -> grayscale -> flat colors -> final render
Every run held these constant:
- same seed
- same model, no style preset, Pro mode
- one image in the Base Image slot
- Single generation, no batch, so the measurement reflects instruction following rather than best of four
- same instruction shape: one sentence naming the stage, one clause listing what stays fixed
Six identifying details were declared up front, chosen to be asymmetric or countable so that survival is checkable rather than arguable: a braid behind the left ear, a badge on the left collar, four tools on the belt, one glove on the left hand, one sleeve rolled and one down, and the thermos inside the ice.
Loading a base image changes the output size without changing the setting. Runs without a base image came back at 960 by 1280, and the identical setting with a base image loaded came back at 896 by 1184. Trust the size on the finished file.
What held
Composition held almost exactly. Aligning edge maps against the line art, the largest displacement across every base-image run was six pixels on a frame 1,184 pixels tall. All six declared details and the camera angle came through every stage.
Run the same finishing instruction directly from the line art, and edge overlap against the original scores 0.168. Run it from the flat color stage instead, and it scores 0.147. Drop the base image entirely and generate from the text alone, and it scores 0.083, with the composition sitting 31 pixels across and 28 down from where the line art put it.
What broke
The chained final render preserved everything and advanced almost nothing.
Measured on the ice surface, the share of pixels sitting on a hard edge went from 15.8 percent at the flat color stage to 24.7 percent after the render instruction. A finishing pass should be moving in the other direction. The same instruction run directly from the line art brought that share to 3.7 percent, and the ice came back translucent.
In an empty patch of white background, the tonal range ran zero in the line art, two in the grayscale, two in the flat colors, then 52 after the chained render step, filled with a blocky mosaic. That pattern was already present at stage two, sitting at an amplitude too low to see. Four passes later it was the most visible thing in the frame. The direct render, from the same prompt text, left the same patch at a range of one.
Why the topology matters
At stage three the model gave the thermos a pale wood handle. My prompt says nothing about a handle color. At stage four that handle arrived unchanged, in the same shape and the same tone, because by then it was pixels in the input image exactly like everything I had specified.
Each pass behaves as though its input image is the whole story. Chaining therefore promotes every intermediate guess to a fact, and on this evidence the later passes had nothing to separate an instruction from an earlier guess.
Across three renders started from the line art rather than the chain, that handle came out dark red once and grey metal twice. Pale wood appeared in none of them. The two chained stages matched each other exactly.
The refactor
Hold the structural base fixed and generate every treatment from it directly:
+-> final render
line art (base) -+-> warm sunset
+-> cool moonlight
+-> strong backlight
Drift stops compounding, because every step reads the same fixed input. The cost is real: a direct render has no access to the intermediate information, so it reinvents anything the middle stages had settled. In my runs the direct version produced the better finish and dropped details the chain had locked in. From one instruction you get one of the two.
That is the configuration behind the four finishes here, one per lighting condition, with only the light changed between them. Composition held in all four, shadows followed the named source, and the stated local colors kept their hue under colored light in three of the four. Under moonlight the warm bias on the stone wall fell from 23 points of red over blue to under one, which is the one case where the light repainted the surface instead of lighting it.
Takeaways
- Treat the earliest artifact that carries the structure as the source of truth, and read from it every time.
- Chaining generations is convenient and lossy. Every pass rewrites the entire image, so anything that survives does so by being redrawn the same way.
- Lock the seed and change one input at a time, or you cannot attribute any difference you observe.
- Declare your checkable details before the run. Asymmetric and countable beats descriptive.
All of the above comes from single generations rather than repeated trials, so treat the direction as the finding and the exact numbers as one sample.
If you want to run the same experiment on a drawing of your own, the model I used is on PixAI.
Top comments (0)