Guide
gpt-image-2.6-flare Image-to-Image Prompt Recipes for Developers
Copy-paste prompt structures, consistency wording, and negative lists for reference-image editing
On this page
What Makes Image-to-Image Prompting Different
Text-to-image prompting is generative: you describe a scene and the model invents everything the prompt does not pin down. Image-to-image prompting is subtractive. The reference image already decides composition, identity, palette, and lighting, and every word you write is an instruction to change as little as possible except here.
That inversion changes what a good prompt looks like. In text-to-image, longer and more detailed usually helps. In image-to-image, extra descriptive words are read as license to redraw. If you write "a woman in a red jacket standing in a park, soft light, cinematic" while editing a headshot, you have invited the model to rebuild the park, the light, and possibly the face.
The practical consequence is that a good edit prompt is mostly made of constraints, not descriptions. You state the single edit you want, then you explicitly fence off everything that must survive untouched: face, pose, framing, background, colors. You also get to spend a few tokens on anchors that tie the output back to the source — "keeping the original camera angle," "same fabric texture as the input" — which is far cheaper than re-describing what is already visible.
Finally, image-to-image behavior is source-dependent. The same prompt applied to a flat product render and to a busy lifestyle photo will drift in different directions, because the model has different amounts of detail to preserve. Treat prompts as recipes tied to an asset type, not universal spells — a point we return to in the testing section.
The mental model to keep
Think of the prompt as an edit order with three jobs: identify what the image is, say what changes, and swear an oath about what does not. Everything else is optional polish.

The Four-Part Prompt Skeleton
Ad-hoc one-liners produce ad-hoc results. A repeatable skeleton makes your edit requests predictable, reviewable, and easy to diff when you A/B test. Use four stacked blocks, in this order:
1. Subject lock
One sentence that names what is in the reference and that it must be preserved.
Use the provided reference image as the source.
Keep the same subject, identity, pose, and framing.
2. Edit instruction
A single, concrete change, phrased as an action. One edit per request is the rule of thumb; chaining three edits multiplies drift.
Change the background to a plain light-gray studio backdrop.
3. Style anchors
Short references that keep the look attached to the input rather than to your imagination. Anchor to the image, not to adjectives.
Match the input's lighting direction, contrast, and color temperature.
Keep the original material textures and edge softness.
4. Negative constraints
A compact list of things that must not appear or change.
Do not change the face, hair, or clothing.
No added props, no text, no watermark.
Do not alter the background beyond the requested replacement.
Assembled, the request reads top-to-bottom as a coherent edit order, and any reviewer can see what you intended. Keep the blocks in this fixed order across your templates: when results regress, you can bisect block by block instead of guessing which sentence caused it.
Why the order matters
Subject lock first prevents the model from treating the edit as a fresh generation. Negatives last means they read as a final guardrail rather than as part of the scene description. Style anchors in the middle bind the new content to the old look.

Copy-Paste Recipes for Common Edits
The templates below assume the four-part skeleton. Swap the bracketed slots; keep the surrounding wording intact until you have a reason to change it.
Background swap
Use the provided reference image as the source.
Keep the same subject, identity, pose, and framing.
Replace the background with [a seamless off-white studio backdrop].
Match the input's lighting direction and shadow softness so the subject
still looks lit by the original light.
Preserve hair and edge detail where the subject meets the new background.
Do not change the subject's face, clothing, or body shape.
No added props, no text, no watermark, no visible cutout edges.
Lighting and mood change
Use the provided reference image as the source.
Keep the same subject, pose, and composition.
Relight the scene as [warm late-afternoon light from the left].
Keep the same materials and textures; only the light and its shadows change.
Do not move or restyle the subject.
Do not change the background geometry.
No color grading beyond the requested lighting shift.
Object replacement
Use the provided reference image as the source.
Keep everything unchanged except the [object] in [region].
Replace it with [a matte ceramic mug of the same approximate size].
Match the perspective, scale, and shadow contact of the original object.
Keep the surrounding surfaces and background identical.
Do not restyle the rest of the scene.
No additional objects, no text.
Cleanup and removal
Use the provided reference image as the source.
Keep the subject and composition exactly as they are.
Remove [the small logo sticker] from [surface] and reconstruct the surface
underneath using the surrounding texture.
Preserve grain, lighting, and color of the original.
Do not alter anything outside that region.
No smudging, no blur, no invented detail.
Wardrobe or color change
Use the provided reference image as the source.
Keep the same person, face, pose, and framing.
Recolor [the jacket] to [deep navy], keeping the original fabric texture,
fold patterns, and lighting response.
Leave skin tone, hair, and background untouched.
Do not change garment shape or fit.
No added accessories, no text.
Each recipe is deliberately one-edit-plus-guardrails. If you need a background swap and a relight, run them as two passes rather than one mega-prompt — the second pass uses the first output as its reference. You can wire both passes through the same gpt-image-2.6-flare image-to-image endpoint with no changes to your client code.

Wording That Preserves Fidelity
Fidelity is not bought with word count. It is bought by naming, explicitly, the things that must not move. Models are good at following enumerated prohibitions and vaguer at inferring your intent from a long positive description.
Name the invariants
Convert every "obviously it should stay the same" into a sentence. A useful checklist for most edits:
- Identity: face, hair, skin, distinguishing features.
- Geometry: pose, camera angle, crop, perspective, object scale.
- Surface: fabric weave, grain, gloss level, material texture.
- Scene: background layout, surrounding objects, horizon lines.
Prefer scoped verbs
"Replace the background" is scoped. "Make it look more professional" is not. Verbs like replace, recolor, relight, remove, extend tell the model where the change stops. Adjectives like better, cleaner, premium invite global redraws.
Tether to the input, not to adjectives
Weak: "keep it cinematic." Strong: "keep the input's contrast, shadow depth, and color temperature." The second phrasing points at pixels the model can see; the first points at a mood it must guess.
State what stays identical, then what changes
Order your sentence so the preserved things come before the change. "Keep the same subject and framing; change only the background" produces tighter results than the reverse, because the constraint is read before the model starts planning the edit.
Add a change budget
A short clause that limits scope is surprisingly effective:
Change only the region described above.
Leave all other pixels as close to the input as possible.
This is the closest thing to a global "minimal diff" instruction and pairs well with a short negative list.
Reuse the input as the style reference
When a project has a defined look, do not re-describe it. Point at it: "match the input's rendering style, grain, and color response." The reference image is the most precise style spec you have.
Holding Style Consistency Across a Set
Editing one image is a prompt problem. Editing a set is a systems problem: you need a shared anchor so variant twenty still looks like variant one.
Pick one anchor image
Choose a single approved output as the style anchor for the project. Every subsequent edit uses two references where the API supports it: the content image to edit, and the style anchor. In the prompt, separate their roles explicitly:
Use the first reference image as the content source.
Use the second reference image only as the style anchor.
Carry over its color palette, contrast curve, grain, and lighting character.
Do not copy its subject, composition, or background.
Naming the roles is essential — without it, models blur the two references and borrow composition from the style image.
Write style anchors as measurable properties
Replace mood words with visual properties that survive across images:
- palette: dominant hues and their relative weight
- contrast: shadow depth and highlight rolloff
- light: direction, softness, color temperature
- texture: grain amount, sharpness, edge treatment
- framing habit: subject scale and headroom
A shared anchor sentence like "match the anchor's palette, shadow depth, and grain" holds a set together better than any adjective stack.
Keep a per-set preamble
Store one preamble string used by every prompt in the project, containing the subject lock and anchor references. Only the edit instruction and specific negatives change per image. This single practice removes most of the "why does image nine look different" debugging.
Freeze and version
When a set is approved, freeze the anchor, the preamble, and the negative list together as a versioned bundle. Future edits start from the frozen bundle, so a later tweak cannot silently restyle the whole set.
Watch for cumulative drift
Chained edits (output of pass one feeding pass two) accumulate small color and contrast shifts. Compare each output against the original anchor, not just against the previous step, and re-anchor if the set starts to wander.
Building a Negative List That Actually Helps
Negative constraints are guardrails, not a wishlist. A short list aimed at the failure modes you actually observed beats a long list of generic prohibitions, which dilutes attention and can even suppress legitimate detail.
Start from observed failures
Run your prompt without negatives first. Log what drifted: added text, a shifted background, a softened face, extra props, a color cast. Each observed failure earns one negative line. Nothing else gets in.
Keep the list short and specific
A working list is usually a handful of items, phrased concretely:
No text, logos, or watermarks.
No added props or people.
Do not change the face, hair, or clothing.
Do not alter the background beyond the requested replacement.
No heavy retouching, no plastic skin, no blur.
Each line maps to a real, repeatable failure. Generic lines like "no bad quality" or "no artifacts" are noise: they name nothing the model can act on.
Split global vs. per-recipe negatives
Keep a small global list (text, watermarks, unwanted people, style drift) shared by every recipe, and a per-recipe list for the specific edit. Background swaps need "no visible cutout edges"; relights need "no color grading beyond the requested shift"; object replacement needs "no additional objects." This keeps prompts short while staying targeted.
Review negatives on a schedule
Prompt drift cuts both ways: a negative that fixed a failure last month may now be suppressing detail you want. Re-read the list whenever you freeze a new version, and delete lines whose failure has stopped appearing.
Do not use negatives for the main instruction
Negatives are poor at creating things. "No busy background" is weaker than "replace the background with a plain light-gray backdrop" plus "no added props." State the positive target, then guard it.
Testing and Iterating Your Recipes
Prompt recipes are code: version them, test them against fixed inputs, and keep the winners. A lightweight loop is enough.
Fix a small evaluation set
Pick a handful of representative source images per asset type — a clean product shot, a portrait, a busy scene. The same recipe behaves differently across them, so test each variant on the whole set rather than a single favorite image.
Change one block at a time
Because your prompts follow the four-part skeleton, you can A/B a single block: keep subject lock, style anchors, and negatives fixed, vary only the edit instruction wording. This isolates cause and effect in a way that whole-prompt rewrites never do.
Compare against a rubric, not a vibe
Write down what "good" means for the asset type: identity preserved, background clean, lighting matched, no text artifacts, edges intact. Score each output per criterion. Subjective ratings collapse when you are comparing twenty near-identical variants; a short rubric keeps decisions consistent and reviewable.
Keep the loop tight
variant -> generate -> compare against rubric -> keep or discard -> freeze winner
When a variant wins, promote it into the versioned recipe bundle: the prompt text, the negative list, the anchor, and the evaluation notes. When one loses, record why in one line. Future you will re-propose the same failed idea otherwise.
Version by asset type
A background-swap recipe tuned on product renders is not a portrait recipe. Version per asset type, and route requests through the same image-to-image model page so switching recipes never means switching plumbing.
Expect recurrence
Model behavior and your source images both change over time. Re-run the evaluation set whenever you refresh the recipe bundle or onboard a new batch of inputs, and retire templates that stop earning their keep.
Good image-to-image work is mostly disciplined constraint-writing: a stable skeleton, explicit invariants, a short negative list, and a versioned loop that keeps what wins.
Related articles
View all articles →-
Guide
gpt-6.2-sol Getting Started Guide: Capability Boundaries, API Integration, and Token Pricing Essentials
Integration decisions and practical essentials for engineering teams
-
Guide
gpt-6.2-astra Getting Started Guide: Text Model Capability Boundaries, Integration Essentials, and Cost Control
-
Guide
Tripo H3.1 Getting Started Guide: Choosing Among Three Input Modes, Parameters, and Pricing
A practical guide for developers on 3D generation integration decisions and cost control