Harnessing the Power of ChatGPT to Generate Stunning Images with DALL-E 2

I want to be straight with you up front: as of May 2026, OpenAI has retired both DALL-E 2 and DALL-E 3 from its API, and ChatGPT moved its built-in image generation onto the newer gpt-image models back in late 2025. So this post is partly a period piece. But the workflow it describes — using a language model to write prompts for an image model, then iterating — has not died at all. It has become the default way everyone generates images, baked so deeply into the tools that most people no longer notice they’re doing it. Understanding the loop on its own terms, separate from whichever model is currently fashionable, is the durable skill. The model names change every eighteen months; the technique does not.

Why pair a language model with an image model at all

The original insight was almost embarrassingly practical. Early image models were brilliant at rendering and terrible at being told what to render. They responded to dense, oddly-specific prompts — “a Dutch Golden Age oil painting of a fox wearing a monocle, dramatic chiaroscuro lighting, 35mm, highly detailed” — far better than to “a fancy fox.” Most people are not natural prompt-writers. They know what they want when they see it, but they can’t conjure the vocabulary of art direction, camera lenses and lighting on demand.

A language model bridges that gap. You describe what you want in plain English, the LLM expands it into the kind of laden, comma-spliced prompt the image model loves, and you feed that forward. It’s a translation layer between human intent and machine appetite. The same division of labour explains why people use ChatGPT for so much else — it’s good at turning vague human goals into precise machine-shaped instructions — though as I argued in Is ChatGPT at a tipping point on the hype scale, it’s worth being honest about where that translation is genuinely useful and where it’s just impressive-looking filler.

There’s a deeper reason the pairing works, and it’s about how the two model types differ. A diffusion image model has no real model of meaning; it has learned correlations between clusters of words and clusters of pixels. Feed it the word “cinematic” and it nudges toward a particular palette and aspect ratio because that’s what images tagged “cinematic” in its training data looked like. It doesn’t understand cinema. The language model, by contrast, does have a usable grasp of what you mean, and it knows which trigger words reliably steer the image model. So you get to speak in intentions while the LLM speaks in triggers — and the gap between those two vocabularies is precisely the thing that used to make image generation frustrating for non-experts. Modern integrated models blur this line by doing both jobs in one system, but the mental model still holds: you describe, something translates, pixels appear.

The loop, step by step

The whole technique is four stages, and the value is in the iteration, not any single step.

1. Describe the goal in plain language. Tell the language model what the image is for, not just what’s in it. “A hero image for a blog post about home networking, calm, slightly technical, no text” gives the model the constraints it needs. The intent matters more than the noun list.
2. Have it write the image prompt. Ask explicitly for a prompt formatted for an image generator, and ask for two or three variants. You’ll often find the variant you didn’t expect is the good one.
3. Generate, then read what you got wrong. This is the step people skip. The first batch is rarely right. The skill is diagnosing why: too cluttered, wrong mood, the subject buried, hands doing something anatomically alarming.
4. Feed the critique back, not a fresh start. Return to the language model with “good, but make the composition simpler and the lighting warmer” rather than starting over. Iterating on a near-miss converges far faster than rerolling from scratch.

That last point is the one that separates people who get good images from people who give up after four tries. It maps almost exactly onto how a good art director briefs a human illustrator: you don’t hand back a blank brief and say “try again,” you say “this is close, push the contrast and lose the background clutter.” The model responds to that kind of bounded, incremental correction far better than to a fresh wall of text, because each round you’re narrowing the space it’s searching rather than restarting from the whole universe of possible images.

One habit pays off more than any other: keep the prompts that worked. When you land a composition you like, save the exact prompt that produced it alongside the image. Over a few weeks you accumulate a personal vocabulary — the lighting phrases, the medium descriptors, the negative constraints that reliably steer the model the way you want — and that library is worth more than any prompt guide written by a stranger, because it’s calibrated to your taste and the specific model you’re using.

Doing it programmatically

If you’re generating images at any volume, the chat box is the wrong interface — you want the API, so the loop can be scripted. The shape of the call has barely changed across model generations; only the model name differs. Here’s the current pattern against OpenAI’s image endpoint (substituting the retired dall-e-2 for the supported gpt-image-1):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from openai import OpenAI
client = OpenAI()

resp = client.images.generate(
    model="gpt-image-1",          # dall-e-2 / dall-e-3 retired May 2026
    prompt="A calm, minimal hero image for an article on home "
           "networking: a single ethernet cable on a soft-lit desk, "
           "shallow depth of field, no text, muted blues",
    size="1536x1024",
    n=1,
)

print(resp.data[0].url or "b64 image returned")

Wrapping that in a script lets you batch a whole set of variants, log the prompts that worked, and keep a library — which is the only sane way to work once you’re producing images regularly rather than occasionally.

Two practical notes from running this in anger. First, watch the costs: image generation is billed per image and the higher resolutions cost meaningfully more, so a script that loops over fifty prompt variants at the top resolution can run up a surprising bill before you’ve looked away. Generate exploratory batches small and cheap, then re-render only the winner at full size. Second, decide early whether you want URLs or base64 back; the API can return either, and if you’re saving to disk in a pipeline the base64 response saves you a second download round-trip and the awkwardness of a signed URL that expires before your script gets to it. Neither of these matters for one-off use, and both matter enormously the moment you automate.

If you’d rather not depend on a hosted API at all — for cost, privacy, or simply the satisfaction of owning the stack — the open-source image models have caught up to the point of being genuinely usable on a single consumer GPU, and the same describe-translate-iterate loop applies to them unchanged. That self-hosting instinct, the same one behind running your own language models locally, turns this from a metered service into a fixed cost of electricity.

Where it goes wrong

A few failure modes recur often enough to name.

The model ignores part of your prompt. Long prompts get their tail-end instructions quietly dropped. The fix is to front-load what matters most and cut the prompt down — a tight prompt that the model fully honours beats a sprawling one it half-reads. If a specific element keeps vanishing, give it its own short prompt rather than burying it in a list.

Text in the image is gibberish. Older image models could not spell, full stop; they produced text-shaped smears. Newer ones are dramatically better but still unreliable for anything beyond a word or two. If you need real text on an image, generate the image without it and add the text afterwards in any editor. Don’t fight the model for legible paragraphs — you will lose.

Hands, and counting generally. Three-fingered hands, six-legged dogs, two left feet. Generation models reason poorly about quantity and anatomy because they’re matching local texture, not assembling a body from a plan. Newer models have improved markedly, but the weakness never fully disappears. Crop around the problem, regenerate with the offending body part out of frame, ask explicitly for “hands in pockets” or “hands out of view,” or simply pick a composition that avoids close-up hands entirely. Fighting the model on anatomy is rarely worth the rerolls.

It looks generically “AI.” Over-saturated, glossy, faintly plastic, that uncanny sheen everyone now recognises at a glance. This is the model’s default house style — the average of everything it was trained on, with the corners sanded off. Counter it by specifying a medium and a constraint — “matte 35mm film photograph, natural light, slight grain” — which pulls it away from the default render toward something with texture and intent. Naming a deliberate imperfection (grain, soft focus, an off-centre composition) is one of the most effective single moves, because perfection is exactly the tell. The goal is an image that looks like a choice was made, not one that looks like the mean of a million stock photos.

A broader caution applies to all of this: treat what the language model tells you about the image, or about the world, with the same scepticism you’d apply to its other confident outputs. The failure mode I picked apart in The limitations of ChatGPT-4 for stock-market predictions — fluent, plausible, and wrong — is exactly the trap that catches people who assume a tool good at describing images is therefore reliable at reasoning about them.

The verdict: who this is for, now

If you need occasional images — a hero for a post, a mock-up, a quick illustration — the LLM-to-image loop is genuinely the fastest route from “I have a vague idea” to “that’ll do,” and it costs pennies per image. For that audience, learn the iteration habit and don’t fuss over which model is underneath; the current default in ChatGPT is fine and improving.

If you’re a working designer or illustrator, the honest answer is more nuanced: these tools are excellent for ideation, moodboards and throwaway comps, and poor for anything needing precise control, brand consistency, or text. They’re a sketchpad, not a replacement for craft. And if you cared specifically about DALL-E 2 — well, it’s gone, and that’s the real lesson of this whole piece. The model you build a workflow around will be retired; the workflow, if you understood why it worked, ports straight to whatever comes next. Learn the loop, not the logo, and you’ll never be stranded by a retirement notice again.