on the article · Technology

ChatGPT’s sketch tool skips the part where you describe things

OpenAI’s Sketch feature turns doodles into prompts, cutting image latency 50% versus its predecessor.

By The Signal · · 5 min read

OpenAI's Sketch tool turns rough doodles into structured prompts for image generation.
OpenAI's Sketch tool turns rough doodles into structured prompts for image generation. — on the article

Drawing a cat with a computer mouse and typing "make the eyes green" is now a complete instruction to a generative image model. OpenAI's ChatGPT Images 2.5, released Tuesday, adds a feature called Sketch that reads a doodle as part of the prompt, not just a picture to imitate. The number that matters isn't the drawing — it's the 50 percent cut in latency OpenAI claims for the underlying model, which is what makes a rough sketch a viable input in the first place.

A round trip that used to take too long to be worth it

Sketch works by letting a user open a drawing canvas inside a chat — triggered by typing @Sketch — make a rough shape, then follow it with a written instruction describing what the finished image should look like. The model treats the sketch as a structural constraint: where the lines are, roughly what they represent, what proportions to hold. The words carry the content: material, lighting, style, color. It's the same division of labor a stone mason uses with a client's tracing paper. The sketch says where the wall goes. The words say what it's built from.

OpenAI also added inline commentary on generated images — a user can click a region of an already-generated picture and leave a note, like "make this blue," rather than rewriting the whole prompt. That's a smaller change but it depends on the same infrastructure: the model has to hold onto enough context about a specific image's regions to accept a follow-up edit without regenerating the whole thing from scratch.

The 50 percent figure comes from OpenAI, measured against its own last model

OpenAI says image generation latency dropped "up to 50%" compared with Images 2.0, the version this replaces. That figure comes from OpenAI's own announcement, not an independent benchmark, and "up to" is doing real work in that sentence — it's a ceiling observed in some cases, not an average across all prompts. No third party has published comparative timing data yet.

Still, the direction is the interesting part. Multi-turn editing — the kind where a user sketches, generates, then asks for three or four follow-up changes — only works as a product if each round trip is fast enough that a person stays in the loop rather than tabbing away. A tool that takes forty seconds per revision teaches people to batch their requests and check back later, which defeats the point of sketch-and-comment interaction. Cut that number and the product changes shape: iterative editing becomes the default way to use it, not an edge case.

Why the number is smaller than the pitch implies

OpenAI frames the release around lighting and texture quality — "more natural lighting and richer textures" — but neither of those claims comes with a measurable benchmark attached, unlike the latency figure. That's a familiar asymmetry in image-model releases: speed is countable in milliseconds, so companies report it; visual fidelity is a matter of taste, so companies describe it in adjectives and let sample images do the arguing. The Verge's own test — a mouse-drawn cat turned into a photorealistic image, eyes recolored via inline comment — worked on one try, on one prompt, reported by one writer. That's a demo, not a distribution. Sketch tools have a long history of working beautifully on cats and struggling on hands, text, and anything with rigid geometric structure, like architecture or vehicles with visible brand marks. OpenAI hasn't published failure-rate data by category, and until it does, "detailed AI images" from "bad drawings" is a claim proven for one bad drawing.

The strongest objection: sketch tools have shipped before, and mostly got ignored

Sketch-to-image interfaces aren't new. NVIDIA's GauGAN, Adobe's various sketch-fill tools inside Photoshop, and multiple research demos going back to 2019 have offered similar functionality — draw a rough shape, get a rendered scene. Most saw modest adoption outside of design-professional workflows, because the people most likely to want a generated image are often the people least likely to want to draw first. Typing a text prompt is faster than opening a canvas, sketching, and then typing anyway. Sketch only earns its keep for a narrower case: someone who has a specific composition in mind — where the cat's tail curves, how the two figures in a scene are positioned relative to each other — that text alone struggles to specify. Composition is the one thing large language models are worst at controlling through words alone, because spatial relationships don't compress well into sentences. That's a real gap, but it's a gap for a subset of users, not a mass-market pitch.

What the latency cut buys OpenAI next, and who notices

Faster inference has a direct cost consequence: less compute time per image means either lower serving cost per image or the same cost supporting more images per user, per plan tier. OpenAI hasn't said which way it's routing that saving — toward margin, toward higher usage caps, or toward subsidizing the extra passes that multi-turn editing generates, since each inline comment triggers a new generation call rather than a free edit. ChatGPT Images 2.5 ships now to ChatGPT, ChatGPT Work, and Codex users across desktop, mobile, and web, according to OpenAI, with no separate pricing tier announced for Sketch itself — it's folded into existing plans.

The constraint nobody's pricing yet is the compute one. Multi-turn, comment-driven editing is a different usage pattern than one-shot generation: a single user session might now generate five or six images where it used to generate one, each iteration cheaper individually thanks to the latency cut but additive in aggregate. If Sketch succeeds at making iteration comfortable, the metric to watch isn't per-image latency — it's images generated per active user per month, and whether that number grows faster than the cost savings that made faster generation possible in the first place.