I may have stumbled onto something interesting while trying to figure out a recurring artifact in ChatGPT image generation and editing (maybe applicable to other models as well?).

It started with a very practical problem:

After several rounds of generative editing on portraits, I would sometimes get this faint cloudy / mottled texture in areas that should have stayed smooth — backgrounds, walls, skin, and other low-detail regions.

At first I wrote it off as normal denoising or regeneration noise. But the more I tested it, the less random it looked.

What first caught my attention

• Running essentially the same edit again could make the artifact better or worse
• The background sometimes became cleaner after another pass
• The face and body often seemed partly protected from whatever was happening
• Sometimes the wall improved while the face actually got worse

That made me wonder whether different parts of the image were being handled differently during editing — preserved in some areas, regenerated in others, perhaps based on some internal mask or segmentation step.

The first useful experiment: shifting the image

Then I tried something slightly odd.

Instead of repairing the image in place, I shifted the entire image by a fixed amount before running the repair. I eventually settled on 20 px for testing.

The idea was simple:

If some hidden spatial pattern is tied to the output canvas, moving the image relative to that pattern should change how strongly it shows up on the subject or background.

And apparently, it did.

I found that:

• repeated edits could reinforce the unwanted texture
• changing the phase relationship sometimes reduced it
• in one case, simply removing the final instruction to “shift back -20 px” improved the result dramatically

That was the first point where this stopped looking like ordinary random noise to me.

Then I started looking at masks and intermediate behavior

I compared:

• the original image
• the first edit
• a second edit based on the first
• extracted masks / intermediate-style outputs

One thing stood out pretty clearly:

The apparently “protected” area often resembled a coarse silhouette of the person.

The face and body tended to remain more stable than the wall, which made me suspect that some regions were being preserved while others were being re-synthesized.

That still didn’t explain the artifact itself, but it could explain why the artifact builds up unevenly.

Then came the black-image test

I tried something much simpler:

Generate a completely black image.

This right here.

Visually, it looked black.

Pixel-wise, though, it wasn’t actually all zeroes. There were sparse non-zero pixels and tiny variations throughout the image.

So I generated multiple independent black images at the same resolution and compared them.

This. It's a different one, I swear!

Or this. A \"completely black image\".

That’s where things got interesting.

contrast, much?

Look. it's full of stars!

What I found

For two independently generated “black” images of the same size:

• correlation between the non-zero pixel masks: 0.848
• Jaccard overlap: 0.766
• expected overlap if the pixels were random and independent: about 0.071
• R/G/B channel correlations: roughly 0.82–0.83
• dominant spatial frequencies were very similar in both images, including peaks around 2.45 px and 5.57 px

Then I applied a large Gaussian blur to both images (sigma = 16).

Shades of Gauss

The result was surprisingly striking: both revealed a very similar large-scale cloud-like structure.

Both \"completely black\" images

The cross-correlation peaked at zero lag, meaning the structured pattern was already aligned at the same canvas coordinates across independent generations.

So whatever this low-level signal is, it doesn’t look purely random. At least part of it appears to be reproducible and locked to the canvas coordinates.

What I think this means — so far

I want to be careful here.

I’m not claiming that this proves OpenAI watermarking, SynthID, or any particular proprietary mechanism.

What I do think the data suggests is this:

Generated images appear to contain a weak, reproducible, canvas-locked spatial pattern — even when the image looks completely black.

A few possible explanations come to mind:

• a watermark-like signal
• deterministic dithering
• quantization or decoder artifacts
• some kind of post-processing step
• something else in the generation pipeline

What now seems much harder to explain this as is simply:

“ordinary random noise”

Why this might matter for iterative image editing

Suppose a weak structured signal really is tied to the output canvas.

An iterative edit might then look something like this:

1. The first image is generated with the structured signal.
2. The image gets edited again.
3. Some regions are preserved while others are regenerated.
4. The regenerated image receives the same or a related structured signal again.
5. After several passes, those signals may begin to reinforce or reveal themselves as visible mottling in smooth areas.

That would fit several things I’ve observed:

• repeated edits can will gradually create ugly texture
• shifting the image relative to the canvas can change the result
• alternating shifts might help decorrelate the artifact
• some regions appear to drift or accumulate artifacts less than others

Important caveat

This is still an investigation, not a conclusion.

At this point I think I have reasonably good evidence for:

• reproducible low-level spatial structure
• non-random alignment between independently generated black images
• a plausible connection between that structure and visible artifacts in repeatedly edited images

What I don’t have yet is proof of:

• the exact mechanism producing it
• whether it is a watermark
• whether it is specific to ChatGPT/OpenAI
• whether similar patterns occur across other image generators

My current working hypothesis

Repeated generative editing can accumulate or expose a weak structured signal that is fixed in output-image coordinates, eventually making it visible as cloudiness or mottling in otherwise smooth areas.

Questions for anyone who has looked into this

1. Have you seen this kind of cloudy / mottled artifact after repeated AI image edits (I mean, come on, who doesn't)?
2. Has anyone tested whether supposedly “black” images from other generators contain reproducible spatial structure?
3. Does this look more like watermarking, dithering, decoder bias, quantization, or something else (go figure!)?
4. Has anyone analyzed something similar in frequency space, after heavy blurring, or using phase shifts?
5. If you’ve run into this before: what turned out to be the most reliable way to prevent it during iterative editing?

If there’s interest, I can post the methodology in a follow-up.

I started with:

“Why does this wall look dirty after I edit it?”

and somehow ended up at:

“Why do two independently generated black images correlate this much?”

Classic rabbit hole.