If you want to know whether an image was made by a machine, it helps to know what the machine is actually doing. Not the marketing version, the real one. And the real one is stranger and simpler than most people assume. A modern image generator does not paint. It does not search a library and paste things together. It starts with a screen of pure static and removes the static, a little at a time, until a picture is left behind.
That's the whole trick. Everything else is detail. But the details are where the tells live, so let's go through them.
The dominant method is called diffusion, and the name is the clue. Picture taking a clean photo and gradually sprinkling random noise onto it, over and over, until nothing is left but Gaussian static, the visual equivalent of a detuned TV. That's the process, and it's easy: you're just destroying information.
forward
The clever part is learning to run it backwards. During training, the model is shown images at every stage of being noised, and its only job is to predict the noise that was added at each step. Do that well enough and you can reverse the whole thing: hand the model pure static, ask "what's the noise here?", subtract its guess, and repeat. After enough passes (usually a few dozen), a coherent image emerges from what started as random pixels.
Nobody told it what a cat looks like. It learned, from examples, what noise isn't, and a cat is what's left over.
A denoiser on its own would produce a plausible image of something. To steer it toward what you typed, the model is conditioned on text. Your prompt is run through a text encoder that turns words into a string of numbers (embeddings), and those numbers are fed into the denoising network through a mechanism called cross-attention at every step.
In effect, the prompt nudges every denoising step toward an image consistent with the description. A knob called classifier-free guidance controls how hard it nudges. Turn it up and the model clings tightly to your words, sometimes at the cost of looking natural; turn it down and it drifts, gaining variety but losing the plot.
This is why a generator could learn what to draw without anyone hand-labeling shapes. It was trained on enormous sets of images paired with their captions: the open dataset LAION-5B, used to train early Stable Diffusion, holds nearly 5.85 billion image-text pairs scraped and filtered from the web. It learned from the same internet we did, captions and all.
The seed: why the same prompt gives different pictures#
Every generation begins from a fresh patch of random noise. Which patch you get is decided by a single number: the seed. Different seed, different starting static, different final image, even with an identical prompt.
The flip side is that the seed makes the process reproducible. Pin the same seed and the same prompt and settings, and you get the same image back, pixel for pixel. So the prompt sets the what, and the seed sets the which one, the particular roll of the dice that the denoising starts from.
Denoising a full-resolution photo, pixel by pixel, dozens of times, would be brutally slow. The breakthrough behind Stable Diffusion was to do all of this in a compressed space instead.
A component called a variational autoencoder (VAE) squeezes an image down to a small grid of numbers that keeps the meaningful structure and throws away redundancy. The diffusion runs in that small space (far cheaper to compute) and only at the very end does a decoder expand the result back into a full picture. Shrinking a 512-pixel image to a 64-pixel grid cuts the work by roughly sixty-fold, which is what made generating images on consumer hardware feasible at all.
Here's the part that pays off if you've ever tried to catch a fake.
For years, two things reliably broke AI images: hands and legible text. Both are examples of fine, rule-bound, repeated structure. A hand has a precise count (five fingers, specific joints, specific proportions), and the model learned hands as a soft statistical blur of "finger-ish things near a palm," not as a thing that must total exactly five. Push it into a complex pose and it would happily produce six fingers, or a thumb growing from the wrong place.
Text is worse, because letters are arbitrary symbols that must be exactly right in exactly the right order. A diffusion model optimizing for "looks plausible overall" had every incentive to render text-shaped scribbles: the right texture, the wrong characters. For a long time, garbled signage was the single most dependable giveaway in the whole game.
That has changed, and you need to know it has. By 2026, the leading systems handle both far better. Text rendering went from a reliable disaster to genuinely usable, and warped hands are markedly rarer than they were. Part of the gain came from a quieter architectural shift: OpenAI's image models, since GPT-4o's native image generation, work autoregressively (predicting the image in pieces the way a language model predicts words) rather than purely by diffusion, which gives them tighter control over symbols like letters.
So be honest about where this leaves you. Counting fingers and squinting at signage still catch the lazy fakes: both still fail in hard cases, like interlaced fingers, extreme foreshortening, or dense small type. But a clean hand and a crisp word no longer prove a human made the image. They used to. They don't anymore.
Knowing the machinery doesn't hand you a magic detector, and anyone selling one is overselling. What it does is recalibrate your instincts. The old tells were artifacts of a model that didn't understand counting or spelling. As the models stop making those mistakes, the artifacts fade, which is exactly why the durable move is not pixel-forensics at all but checking where a picture came from, through provenance signals like the C2PA content credentials standard, and treating "looks real" as the beginning of the question, not the end.
If you'd rather train the instinct than memorize a rulebook, the rest of our guide to spotting AI images walks through what still holds up. And today's puzzle is five items waiting to fool you: good practice, no stakes.
Do AI image generators copy or stitch together existing photos?
No. A diffusion model doesn't keep a library of images to paste from. It learns statistical patterns from billions of image-and-caption pairs, then builds a new picture by removing noise step by step. The result can echo styles it saw in training, but it isn't a collage of stored photos.
Why do two people get different images from the exact same prompt?
Because the prompt isn't the only input. Each generation starts from a different patch of random noise, picked by a number called the seed. Same prompt, different seed, different picture. Reuse the same seed with the same prompt and settings and you'll get the same image back.