Blog

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

Nov 17, 2026 12 min read
Cover art: pale mauve and ink black color fields split by one hard diagonal edge with a thin violet seam.
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.

Text-to-image flows from a single prompt; image-to-image interleaves a reference with the prompt to reach the edit.

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.

Four stacked prompt components converge into one combined edit request.

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.

Each edit category maps to its own copy-paste recipe card.

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 →

Start building with persistent AI artifacts

Get your API key and call image, video and audio models through one task-based API.

Read the API docs