DEV Community: Voor AI

Build a Brand-Image Contract Before Generating Campaign Variants

Voor AI — Wed, 12 Aug 2026 02:52:42 +0000

“Keep the brand consistent” is not an executable requirement. A useful image workflow separates invariants—things that may not change—from variables that make each campaign asset new.

This tutorial uses the current Banana Pro AI Studio page on Voor. The exact route exposes a Prompt, optional Image Input, Aspect Ratio including Match Input Image, Public visibility, Reset, and Generate. It presents real product-studio and campaign examples. The live form supplies the current model and credit estimate before submission; no credits were spent here.

1. Encode the invariants

{
  "identity": {
    "product_shape": "short cylindrical bottle with rounded shoulder",
    "cap": "matte black, same height and diameter",
    "label": "cream field, centered two-line wordmark",
    "logo_geometry": "unchanged"
  },
  "materials": {
    "bottle": "amber glass",
    "label": "uncoated paper"
  },
  "must_not_change": [
    "label spelling",
    "cap proportions",
    "bottle silhouette"
  ]
}

Use observable nouns and proportions. “Premium” is a direction; “matte black cap with the same height and diameter” is a constraint.

2. Keep campaign variables separate

{
  "campaign": {
    "environment": "cool stone shelf after rain",
    "lighting": "soft overcast window light",
    "accent": "single eucalyptus stem",
    "crop": "4:5 social hero",
    "negative": ["extra bottles", "floating text", "new logo"]
  }
}

Now you can change environment, lighting, prop, and crop without rewriting the product identity. Version both JSON blocks with the final asset.

3. Assemble a constraint-first prompt

Put invariants before style:

Preserve the exact bottle silhouette, matte-black cap proportions, cream label, and centered two-line wordmark from the input. Place one bottle on a cool stone shelf after rain, soft overcast window light, one eucalyptus stem, 4:5 crop. No extra bottles, no new copy, no logo redesign.

Upload the approved product master, select Match Input Image when geometry is the test, then switch aspect ratio only for a documented channel requirement. Check Public before using unreleased packaging. Read the displayed credit estimate before Generate.

4. Validate with code

A small contract checker prevents missing review fields:

const required = [
  "product_shape",
  "cap",
  "label",
  "logo_geometry"
];

export function validateBrief(brief) {
  const missing = required.filter(key => !brief.identity?.[key]);
  if (missing.length) throw new Error(`Missing invariants: ${missing.join(", ")}`);
  if (!brief.campaign?.crop) throw new Error("Missing campaign crop");
  return true;
}

This does not inspect pixels; it makes the human review checklist deterministic. Pair it with a contact sheet showing the product master beside every variant.

5. Reject identity drift before polishing

At 200% zoom, check silhouette, cap, wordmark letters, label margins, glass tint, and highlights. Then review at thumbnail size for campaign hierarchy. Reject a beautiful scene if the product is no longer the product.

The two images above are real examples on the current Banana Pro AI Studio route. They illustrate separate production directions; they are not a promise that arbitrary packaging text will always be exact.

Use the exact Banana Pro AI Studio workspace to test one controlled variable at a time, and keep the invariant contract beside every approved export.

How to Edit Body Shape in a Photo Without Bending the Background

Voor AI — Tue, 11 Aug 2026 03:13:31 +0000

Generative body edits often fail outside the body. A waist changes—and a doorframe curves. A shoulder narrows—and wallpaper slides. The most useful QA artifact is therefore not a beauty score; it is a change mask over the full frame.

This workflow uses a consented photo and the current Voor AI Body Editor, whose live Seedream 4.5 workspace exposes an image input, prompt, aspect ratios, Public, and Generate. The before/after pair in this post is a real example from that exact route.

1. Set an edit boundary

Write the request as a small delta:

Make a subtle, anatomically plausible adjustment to the jacket waist only. Preserve the person's face, identity, hands, pose, clothing texture, camera crop, floor line, wall edges, and every background object. No skin exposure and no new accessories.

Do not ask for a vague “perfect body.” It has no measurable boundary and encourages the model to redesign the whole photograph.

Check consent and the Public control. During verification, the current default one-image request estimated 14 credits; inspect the live estimate before Generate.

2. Normalize the images

Save the source as before.png and the candidate as after.png. They should have the same dimensions. This Python script creates an amplified change mask and a checker overlay:

from PIL import Image, ImageChops, ImageEnhance, ImageDraw

before = Image.open("before.png").convert("RGB")
after = Image.open("after.png").convert("RGB")
assert before.size == after.size, "Compare equal-size images"

diff = ImageChops.difference(before, after)
mask = ImageEnhance.Contrast(diff).enhance(4.0)
mask.save("change-mask.png")

review = after.copy()
draw = ImageDraw.Draw(review, "RGBA")
w, h = review.size
step = max(32, min(w, h) // 12)
for x in range(0, w, step):
    draw.line((x, 0, x, h), fill=(0, 255, 255, 95), width=1)
for y in range(0, h, step):
    draw.line((0, y, w, y), fill=(0, 255, 255, 95), width=1)
review.save("grid-review.png")

The mask answers “where did pixels change?” The grid answers “did straight structures stay straight?” Neither decides whether an edit is appropriate; they expose drift for a human reviewer.

3. Define the allowed region

Create a rectangle around the intended edit and calculate how much difference lies outside it:

import numpy as np
from PIL import Image, ImageChops

before = Image.open("before.png").convert("RGB")
after = Image.open("after.png").convert("RGB")
d = np.asarray(ImageChops.difference(before, after), dtype=np.float32).mean(2)

# Replace with the permitted x1, y1, x2, y2 region.
x1, y1, x2, y2 = 420, 260, 760, 820
allowed = np.zeros_like(d, dtype=bool)
allowed[y1:y2, x1:x2] = True

changed = d > 12
outside_ratio = (changed & ~allowed).sum() / max(changed.sum(), 1)
print(f"changed pixels outside allowed region: {outside_ratio:.1%}")

This threshold is diagnostic, not universal. Compression, relighting, and resampling can change many pixels. Compare several candidates under the same settings rather than declaring one magic pass/fail value.

4. Run a human geometry review

At 200% zoom, follow every nearby straight edge through the edited zone: doorframes, shelves, tiles, horizons, table legs. Then inspect hands, elbows, garment seams, repeated textures, shadows, and contact with furniture.

Finally, blink between before and after at fit-to-screen size. If the entire scene appears to “breathe,” the edit escaped its boundary.

5. Reject, narrow, or disclose

If background changes dominate, reject the candidate. If one edge drifts, tighten the prompt around the exact garment region. Keep the untouched source and label the exported version as edited. Never use body edits to bully, sexualize, or deceive a subject.

The real pair shown here demonstrates the correct review target: the intended change is only one part of the frame; stable background geometry is the acceptance criterion.

Try the method in the exact Voor body editor, then let the change mask—not wishful viewing—tell you where the model wandered.

How to Add Depth of Field to a Photo With an Edge-Safe Focus Map

Voor AI — Mon, 10 Aug 2026 06:51:24 +0000

Adding synthetic depth of field is a segmentation problem before it is a blur problem. Define what must stay sharp, add a protected edge band around it, and reject any result that blurs across the subject boundary.

This comparison uses the app's stored first-party input and result. No new generation was submitted for this tutorial.

Model the focus map

Use the visible skateboarder as the foreground subject and split the image into three regions:

type Region = "sharp" | "transition" | "blur";

interface FocusMap {
  subject: string[];
  protectedEdges: string[];
  background: string[];
  blurIntent: "ultra-shallow" | "shallow" | "moderate";
}

const map: FocusMap = {
  subject: ["face", "hair", "shirt", "shorts", "arms", "legs", "skateboard"],
  protectedEdges: ["hair silhouette", "fingers", "shirt", "legs", "board edge"],
  background: ["sky", "tree line", "road", "distant grass"],
  blurIntent: "ultra-shallow"
};

The transition region matters most. A uniform blur mask will either leave the background too sharp or cut into hair and fingers.

Use the direct Depth Of Field app

Open the current Depth Of Field workspace. The live page describes FLUX.1 Kontext [pro], requires an Input Image, currently defaults Blur Effect to ultra shallow depth of field, offers Match Input Image and PNG, exposes Seed under Advanced Settings, and shows Public plus Generate.

Use a source with a clear foreground subject and enough background distance to make the requested optics plausible. Keep Match Input Image so edge comparisons remain aligned.

Translate the map into a narrow instruction

Avoid merely saying “cinematic bokeh.” Name the plane, protected boundary and background behavior:

Keep the skateboarder, face, hair, shirt, arms, legs and board completely sharp. Add ultra-shallow depth of field only behind the outer body and skateboard edges. Use a soft graduated transition; blur the sky, tree line, road and distant grass into natural optical bokeh. Preserve pose, crop, lighting and foreground edges. No halo, cutout edge or radial blur.

If the app's Blur Effect control already expresses the strength, use the prompt to describe placement and exclusions rather than repeating decorative adjectives.

Run an edge validator

Review at 200% zoom. Sample pixels on both sides of difficult boundaries:

interface EdgeSample {
  name: string;
  subjectDetailRetained: boolean;
  backgroundSoftened: boolean;
  haloVisible: boolean;
}

const validEdge = (e: EdgeSample) =>
  e.subjectDetailRetained && e.backgroundSoftened && !e.haloVisible;

Test flyaway hair, glasses, fingers, translucent fabric and reflective edges. Then zoom back to 100% and check whether the blur direction and intensity feel like one lens rather than a painted mask.

Separate optical errors from content errors

Halo: widen the transition band and ask for gradual optical falloff.
Blurred hair: name the full hair silhouette as sharp.
Sharp holes in the background: enumerate visible background objects.
Radial smear: request lens-like bokeh, not motion blur.
Changed face or clothes: reduce the change set to background defocus only.

Execution constraints

The live credit estimate can depend on account state and completed inputs. Inspect it immediately before Generate rather than hard-coding a number. Keep Public only if the uploaded image may be publicly visible. Use photos you own or are authorized to edit.

Physical limitations

An AI blur is not a recovered depth map or a substitute for optical capture. Fine transparent edges, reflections and overlapping objects may be inferred incorrectly. Keep the original and disclose synthetic editing when documentary context matters.

Once every protected boundary is listed, run the edit in the exact Voor depth-of-field app and make the edge validator—not aesthetic excitement—the release gate.

How to Build a Camera-Movement Prompt Contract for AI Video

Voor AI — Sun, 09 Aug 2026 04:12:18 +0000

“Make it cinematic” is not a camera plan. A reproducible AI-video brief needs a move type, path, speed, subject lock, horizon rule, and stop condition. Voor’s current 3D Camera Transform page exposes a direct form with Seedance 1.5 Pro, image and optional last-frame inputs, a five-second default, 16:9, Public visibility, and Generate.

Represent the move as data

type CameraMove = {
  move: "orbit" | "dolly-in" | "dolly-out" | "crane";
  degrees?: number;
  speed: "slow" | "medium";
  target: string;
  distance: "constant" | "closing" | "opening";
  horizon: "stable";
  preserve: string[];
};

const brief: CameraMove = {
  move: "orbit",
  degrees: 15,
  speed: "slow",
  target: "centered electric coupe",
  distance: "constant",
  horizon: "stable",
  preserve: ["vehicle geometry", "wheel count", "studio lighting", "background layout"]
};

Compile the contract into a prompt

function toPrompt(x: CameraMove) {
  return [
    `${x.speed} ${x.degrees ?? ""}-degree ${x.move} around the ${x.target}`,
    `${x.distance} camera distance`,
    `${x.horizon} horizon`,
    `preserve ${x.preserve.join(", ")}`,
    `one continuous move, no cuts, no zoom, no subject motion`
  ].join("; ");
}

The negative constraints matter. Orbit and zoom are different operations; asking for both often creates an unstable hybrid.

Run the current direct generator

Open the 3D Camera Transform workspace. Verify Seedance 1.5 Pro, upload an authorized still, leave the optional last frame empty for the first test, keep five seconds and 16:9, and choose visibility intentionally. The signed-in form calculates credits from the selected duration and required inputs; read that live estimate before pressing Generate.

Validate the output deterministically

Use a five-item acceptance test:

const checks = {
  continuousShot: true,
  horizonStable: true,
  targetCentered: true,
  geometryPreserved: true,
  moveStopsAtRequestedAngle: true
};

if (Object.values(checks).some(v => !v)) {
  throw new Error("Reject camera pass");
}

Frame-scrub the clip at the start, midpoint, and end. Track wheel count, window shapes, logos, and horizon angle. A smooth clip can still fail if the vehicle mutates.

Failure modes

Orbit becomes zoom: state constant distance and no zoom.
Subject rotates instead of camera: say the subject remains stationary.
Horizon rolls: explicitly require a stable horizon.
Background melts: lock major planes and keep the angle modest.
Cut appears: require one continuous shot.

Limits

A prompt contract improves reviewability; it does not guarantee physical 3D reconstruction. The model estimates unseen surfaces. Larger angles reveal more invented geometry, so a 15-degree test is safer than a full orbit. Model availability, duration, visibility, and credit estimates are live facts and can change.

Use the current Voor camera-movement form only after the contract can be checked frame by frame.

How to Create AI Videos With Dialogue Using a Three-Beat Script Contract

Voor AI — Sat, 01 Aug 2026 02:29:12 +0000

An AI dialogue clip is easier to debug when the prompt is a tiny production contract: one speaker, three ordered beats, one quoted line, causal sound, and a stable ending. This tutorial turns that contract into JSON, validates it, and maps it to the current HappyHorse 1.1 form.

Workspace proof: HappyHorse 1.1 dialogue mode, prompt, duration, aspect ratio, visibility, and Generate controls

1. Define the data contract

{
  "duration_seconds": 5,
  "aspect_ratio": "16:9",
  "speaker": "Maya, bakery owner",
  "identity_lock": ["face", "green apron", "silver name pin"],
  "beats": [
    {"start": 0, "end": 1.5, "action": "Maya sets a warm loaf on the counter"},
    {"start": 1.5, "end": 3.8, "dialogue": "Fresh at six. Still warm."},
    {"start": 3.8, "end": 5, "action": "She smiles and holds the loaf steady"}
  ],
  "audio": ["soft tray contact", "quiet bakery room tone"],
  "forbid": ["music", "second speaker", "camera cut", "on-screen text"]
}

The contract is intentionally small. Five seconds cannot support a product demo, two characters, three camera moves, and a paragraph of speech.

2. Validate before prompting

function validateScene(scene) {
  const errors = [];
  if (!Number.isFinite(scene.duration_seconds)) errors.push("duration required");
  if (scene.beats.length !== 3) errors.push("exactly three beats required");
  if (scene.beats[0]?.start !== 0) errors.push("timeline must start at 0");

  for (let i = 0; i < scene.beats.length; i++) {
    const beat = scene.beats[i];
    if (!(beat.end > beat.start)) errors.push(`beat ${i + 1} has invalid range`);
    if (i && beat.start !== scene.beats[i - 1].end) {
      errors.push(`gap or overlap before beat ${i + 1}`);
    }
  }

  const end = scene.beats.at(-1)?.end;
  if (end !== scene.duration_seconds) errors.push("timeline must fill duration");
  const spoken = scene.beats.filter(b => b.dialogue).length;
  if (spoken !== 1) errors.push("use exactly one dialogue beat");
  return errors;
}

Fail the build if the validator returns any error. That is cheaper than discovering an impossible timeline after generation.

3. Compile JSON into a prompt

HappyHorse 1.1 dialogue scene, 16:9, five seconds, one continuous medium shot.
0–1.5s: Maya, a bakery owner in a green apron with a silver name pin, sets a warm loaf on the counter.
1.5–3.8s: she looks toward camera and says exactly, “Fresh at six. Still warm.”
3.8–5s: she smiles and holds the loaf steady for a clean ending.
Preserve face, apron, pin, loaf, counter, and light direction. Soft tray contact and quiet bakery room tone only. No music, second speaker, camera cut, captions, or extra text.

Paste the compiled prompt into the HappyHorse 1.1 dialogue workspace. The live page currently selects Text to Video and Dialogue scene, defaults to five seconds and 16:9, exposes Public visibility, and offers Generate. The model supports audio.

4. Treat cost as part of the contract

The current five-second, 720p pricing configuration calculates to 488 credits in the read-only model data. Do not hard-code that number in an app: request or read the live UI estimate before submission. Three welcome credits do not cover this default video setup.

5. Review as a state machine

Check the clip in three passes:

Silent: identity, prop geometry, camera continuity, final hold.
Audio only: exact words, no surprise speaker, causal contact sound, steady room tone.
Combined: mouth motion aligns with the quoted line and audio events match visible actions.

Reject when a beat changes order, two people speak, the line is paraphrased, the camera cuts, or the final pose is unstable.

Troubleshooting

Dialogue runs long: shorten the line; do not speed the character unnaturally.
Lip sync drifts: keep one speaker and place the line in one continuous beat.
Wardrobe changes: repeat the identity lock once, near the end of the prompt.
Audio invents music: explicitly request room tone and forbid music.
The model adds captions: add “no on-screen text”; composite approved captions later.

Limits

Generation is nondeterministic even when the JSON is deterministic. The validator proves timeline structure, not output quality. Public is the current default visibility. No paid generation was submitted for this tutorial, and model availability or pricing may change.

When your contract validates, run it in the exact HappyHorse 1.1 generator after checking the live estimate.

How to Use ControlNet With a Reproducible Structure Manifest

Voor AI — Fri, 31 Jul 2026 09:54:12 +0000

ControlNet works best when the reference image is treated as an explicit structural input, not as vague inspiration. Pick one control signal, record what geometry must survive, generate, and compare the output against a small manifest.

Choose the right control signal

Use Canny when hard outlines and object placement matter. Use Depth when camera perspective and front-to-back relationships matter more than every edge. Mixing both concepts in one undocumented prompt makes failures hard to diagnose.

The current Voor ControlNet form has a required Prompt, a Control Image upload, and a visible Generate button. Its own guidance distinguishes geometry-first ControlNet from identity/texture-first image-to-image work. The public form does not expose a numeric credit estimate before sign-in, so verify the live estimate before generating.

Define a structure manifest

{
  "controlType": "canny",
  "mustPreserve": [
    "camera_angle",
    "product_outline",
    "handle_position",
    "ground_contact"
  ],
  "mayChange": [
    "material",
    "color_palette",
    "background",
    "lighting"
  ],
  "forbidden": [
    "extra_handles",
    "floating_shadow",
    "cropped_product"
  ]
}

This manifest becomes both the prompt plan and the review plan.

Build the prompt from changeable layers

Keep the reference camera angle, outer product silhouette, handle position,
and ground contact. Change the material to matte cobalt ceramic, use a warm
studio gradient background, soft key light from upper left, realistic contact
shadow. No extra handles, no floating object, no crop.

Open the ControlNet generator, upload a clean reference, and start with one control type. A source with a single readable subject will produce a more useful edge or depth map than a cluttered scene.

Add a deterministic validator

The image review is visual, but the decision rules can still be deterministic:

const required = new Set([
  "camera_angle",
  "product_outline",
  "handle_position",
  "ground_contact",
]);

export function validateReview(review) {
  const seen = new Set(review.preserved ?? []);
  const missing = [...required].filter((key) => !seen.has(key));
  const forbidden = review.failures ?? [];

  return {
    ok: missing.length === 0 && forbidden.length === 0,
    missing,
    forbidden,
  };
}

const review = {
  preserved: [
    "camera_angle",
    "product_outline",
    "handle_position",
    "ground_contact",
  ],
  failures: [],
};

console.log(validateReview(review));

This is intentionally simple. It prevents “looks good” from replacing the requirements.

Review in a fixed order

Compare the camera angle.
Compare the outer silhouette.
Check intersections and repeated lines.
Inspect small geometry: fingers, handles, labels, hinges.
Check the contact shadow.
Only then score material and lighting.

Troubleshooting

Too rigid: simplify the reference or reduce conflicting prompt detail.

Too much drift: use a cleaner source and name fewer allowed changes.

Canny preserves clutter: crop the source or switch to Depth.

Depth loses product edges: return to Canny for the geometry-critical pass.

The model copies source texture: state the new material and palette explicitly.

Technical limits

ControlNet can preserve the broad map while breaking local geometry. It does not guarantee identity, readable labels, valid hands, physical safety, or pixel-perfect correspondence. Model behavior and credit estimates can change; record the live settings with each approved output.

When your manifest is ready, run one controlled pass and validate it before changing a second layer.

How to Generate Multiple Images With AI From a Variation Matrix

Voor AI — Thu, 30 Jul 2026 02:34:36 +0000

Generating multiple images reliably is a data-contract problem before it is a prompting problem. Define the invariant visual system once, express only allowed differences in a matrix, generate a small pilot, and validate every output against the same rules.

Define the contract

For a four-icon onboarding set, keep invariants and variables separate:

system:
  canvas: "4:3"
  background: "#F7F8FC"
  stroke: "6px rounded navy"
  lighting: "flat, no shadows"
  forbidden: ["text", "logos", "gradients"]
items:
  - id: upload
    object: "document entering an arrow tray"
    accent: "#6C5CE7"
  - id: review
    object: "magnifier over a four-tile grid"
    accent: "#00B894"
  - id: approve
    object: "check mark inside a shield"
    accent: "#0984E3"

Open the Voor Bulk Assets Creator, choose GPT Image 2 and the Icon set preset, then put the invariant block first. Append one item row per generation.

Build a deterministic prompt function

function promptFor(system, item) {
  return [
    `Create one ${item.object}.`,
    `Canvas ${system.canvas}; background ${system.background}.`,
    `Use ${system.stroke}; accent ${item.accent}.`,
    `${system.lighting}.`,
    `Do not include ${system.forbidden.join(', ')}.`
  ].join(' ')
}

Keep order stable so prompt diffs stay reviewable. Do not inject random style adjectives between rows.

Pilot before the batch

Generate two contrasting items first. The current GPT Image 2 default family estimate observed today was 4 credits, but size/model changes can alter it; confirm the live estimate and public-visibility setting before Generate. If the pilot fails, edit the contract rather than patching each item separately.

Validator

const required = ['canvas', 'background', 'stroke', 'lighting'];
function validateRow(row) {
  const missing = required.filter(k => !row.system?.[k]);
  if (missing.length) throw new Error(`Missing: ${missing.join(', ')}`);
  if (!/^#[0-9A-F]{6}$/i.test(row.item.accent)) throw new Error('Bad accent');
}

Visual QA still needs humans. Check canvas, background, stroke weight, object count, forbidden text, and semantic accuracy. Record pass/fail by item ID.

Troubleshooting

Style drifts: move the shared style block to the beginning and remove synonyms.

Objects multiply: say “one centered object” and reject extra props.

Colors mutate: provide exact hex values plus color names.

One item needs a special exception: add an explicit exceptions field; do not silently change the global contract.

Limits

This is not a transactional batch API: generation may remain variable, and exact pixel identity is not guaranteed. The current model, credit estimate, and availability can change. Public is the current default, so switch it for confidential assets. Generated icons also require license, trademark, and accessibility review.

Once the matrix passes validation, run the small pilot in the exact bulk workspace.

Reference-First AI Image Editing: How to Change One Thing Without Redesigning Everything

Voor AI — Wed, 29 Jul 2026 12:49:51 +0000

AI image editing is most useful when it behaves like a controlled revision rather than a fresh generation. The difficult request is rarely “make a completely different picture.” It is usually “change the label, lighting, material, or background while keeping the subject recognizably the same.”

That requires a different prompting habit. Instead of describing only the desired result, separate the brief into what may change and what must remain stable. I use this approach in the FLUX 3 AI Image Generator, where FLUX 3 is labeled as coming soon and the live FLUX.2, Pro, and Max routes handle current generation and reference edits.

Start with a usable reference

A reference image is not just inspiration. For an editing workflow, it is the source of truth for identity, geometry, composition, and brand details.

Before uploading it, check:

the subject is large enough to inspect;
important text is readable;
product edges are not hidden by hands or props;
lighting reveals the material you need to preserve;
the crop leaves enough room for the requested change;
compression artifacts are not mistaken for texture.

If the reference already contains a major ambiguity, the edit will inherit it. A clean input reduces the number of decisions the model has to invent.

Write a two-column brief

I draft every revision as two mental columns.

Change

Name the smallest useful modification:

replace the background with pale concrete;
change the bottle cap from black to brushed aluminum;
update the headline to an exact phrase;
move the key light from camera left to camera right;
turn a daytime sky into early blue hour.

Preserve

List the properties that define continuity:

subject identity and facial features;
product silhouette and proportions;
label layout, logo placement, and typography;
camera angle, focal length, and crop;
hand position and object contact;
color of every element not named in the change;
background perspective and shadow direction.

A compact edit prompt might read:

Replace the glossy black cap with brushed aluminum. Preserve the bottle geometry, label typography, logo position, camera angle, crop, hand pose, liquid color, background, and shadow placement. Do not add new text or props.

The preservation sentence is not filler. It defines the acceptance criteria.

Avoid style words that reopen the whole image

Terms such as “cinematic,” “premium,” and “modern” are broad. They invite the model to reinterpret many visual choices at once. If the goal is a controlled edit, translate style into physical decisions.

Instead of “make it premium,” write:

Use a narrow softbox reflection on the left edge, a subtle warm rim light, lower background saturation, and a clean commercial product-photography finish. Preserve the camera angle and product material.

Concrete direction makes it easier to compare the output with the reference.

Handle text as exact content

Text edits need three pieces of information:

the exact replacement string;
its location and hierarchy;
the surrounding text that must remain unchanged.

For example:

Replace only the top headline with “DESIGNED FOR QUIET WORK”. Keep the existing typeface style, letter spacing, alignment, white color, and all smaller body text unchanged.

Use quotation marks around required copy. After generation, inspect every character at full resolution. Even when typography looks plausible at thumbnail size, small substitutions can remain.

Change one variable per iteration

Suppose the requested final image needs a new headline, warmer light, and a different surface material. Doing all three in one pass makes failure hard to diagnose.

A more reliable sequence is:

Pass 1: fix the headline while preserving everything else.
Pass 2: adjust light direction and color temperature.
Pass 3: change the surface material.
Pass 4: run a higher-detail final revision only after composition is approved.

Save the prompt and output for each pass. If a later edit damages the label or silhouette, return to the last stable image rather than trying to repair several accumulated errors.

Choose the model for the stage

A fast model is useful for checking whether the instruction is understood. A production-oriented model is more appropriate after the edit logic is stable. A higher-detail route should be the final step, not the first experiment.

This keeps iteration affordable and reduces the temptation to accept a costly but structurally wrong image just because it looks polished.

Review at three scales

Every result should be checked in three views.

Thumbnail

Does the composition still communicate the same idea? Is the requested change immediately visible?

Normal view

Are lighting, materials, edges, and spatial relationships coherent? Did any unintended object appear?

Full resolution

Inspect text, logos, hands, jewelry, product seams, reflections, repeated patterns, and fine facial details. These are the places where continuity errors often hide.

A reusable editing template

Change: [one specific revision]. Preserve: [identity, geometry, composition, typography, palette, and untouched elements]. Physical direction: [light, material, lens, or layout details]. Exact text: [quoted copy and placement, if any]. Do not: [new objects, extra text, changed crop, or other common failure].

Reference-first editing is intentionally conservative. The goal is not to ask the model for a more impressive image every time. The goal is to make one approved change while protecting the decisions that are already correct.

Shot-First AI Video Prompting: A Repeatable Workflow for Product Demo Clips

Voor AI — Wed, 29 Jul 2026 12:47:48 +0000

Short AI video looks easy until a prompt has to survive several iterations. The usual failure mode is not a weak model. It is an overloaded brief: three actions, two camera moves, a lighting transition, a product reveal, dialogue, and sound design are all packed into one short clip.

A more reliable approach is to treat every generation as a single shot with one visible event. This article describes the workflow I use when planning short product demos and social clips. I test the brief in the FLUX 3 Video Generator, where FLUX 3 Video is clearly marked as coming soon and live alternatives such as Seedance, HappyHorse, and Kling can be used today.

1. Define the job of the shot

Before writing visual details, finish this sentence:

At the end of this clip, the viewer should understand that ______.

For a product demo, the answer might be “the dashboard turns a text brief into three visual options” or “the mobile app identifies the plant and explains how to care for it.” If the sentence contains “and” more than once, the shot is probably doing too much.

This constraint helps in two ways. It keeps the visible action readable, and it gives you a clear test for the output. A beautiful result that does not communicate the intended change is still a failed demo.

2. Write the event in chronological order

Models respond better when the prompt follows the timeline the viewer will see. I use this order:

Establish the subject and starting state.
Describe one action.
Describe the camera response.
Describe the lighting or environmental change.
Add sound or dialogue cues.
State the ending frame.

For example:

A matte black field recorder rests on dark volcanic glass. A hand enters from frame right and presses the illuminated record button. The camera makes a slow 10-centimeter push-in while the cyan status light brightens. A soft mechanical click and low room tone are audible. End on a stable close-up with the display readable.

Notice that the prompt does not jump between the beginning and the ending. Every instruction has a place on the timeline.

3. Separate subject motion from camera motion

“Dynamic” is not a camera instruction. Neither is “cinematic.” If motion matters, name it precisely.

Useful camera phrases include:

locked tripod frame;
slow push-in;
lateral slider move from left to right;
handheld follow with restrained micro-movement;
overhead tilt down;
static macro close-up.

Then describe the subject independently: turns, lifts, opens, rotates, steps forward, or changes expression. When both motions are stated separately, it is easier to diagnose which part failed.

4. Use a reference image as a contract

Image-to-video works best when the source image already contains the composition you want to preserve. The reference should answer the expensive questions before generation: product angle, wardrobe, layout, palette, and background.

The motion prompt should then focus on what changes. I usually include one explicit preservation sentence:

Preserve the product geometry, label typography, surface material, and background composition.

This is especially useful for brand assets. Asking the model to redesign the product and animate it in the same pass creates unnecessary variation.

5. Direct audio on the same timeline

When a live model supports native audio, treat sound as part of the shot rather than a note at the end. Attach each cue to a visible action:

the latch clicks as the case opens;
footsteps become louder while the subject approaches;
dialogue begins after the camera settles;
room ambience falls away when the screen turns on.

For dialogue, keep the line short enough for the duration. A five-second clip cannot comfortably hold a long sentence plus a product action. If the wording is essential, consider a separate voiceover pass instead of forcing synchronized speech.

6. Draft cheaply, then change one variable

The first generation is a measurement, not a final deliverable. Use a lower-cost model or draft setting to test timing and composition. After each result, identify the largest visible error and change one variable only.

A simple iteration log might look like this:

Draft 1: action is readable, camera moves too fast.
Draft 2: camera fixed, button press happens too early.
Draft 3: timing fixed, reflection hides the display.
Draft 4: lighting adjusted, approved for final render.

Changing several instructions at once makes it impossible to know which edit improved the result. Controlled iteration also gives reusable language for future shots.

7. Use an acceptance checklist

Before approving a clip, review it at normal speed and frame by frame:

Is the intended event understandable without explanation?
Does the subject remain consistent?
Is product text or geometry distorted?
Does camera motion match the instruction?
Are hands, edges, and reflections stable?
Do sound cues align with visible events?
Does the final frame provide a clean editing point?

If the answer to the first question is no, do not polish the shot. Rewrite the event. If the event works but one detail fails, revise only that detail.

A compact reusable template

Here is the full structure in one block:

Starting frame: [subject, environment, composition]. Action: [one visible event]. Camera: [one precise movement or locked frame]. Light: [specific change or stable condition]. Audio: [ambience, effect, or short dialogue tied to the action]. Preserve: [identity, geometry, typography, palette]. Ending frame: [stable final composition].

This process is deliberately less exciting than writing one giant “cinematic” prompt. That is the point. A good production workflow makes results easier to evaluate, revise, and repeat.

How to Edit Text in an Image With AI Without Redesigning It

Voor AI — Wed, 29 Jul 2026 03:09:20 +0000

The safe way to edit text in a flat image is to define a small patch contract: exact old string, exact new string, one target region, and an explicit list of pixels that must remain semantically unchanged.

Input contract

source:
  permission: owned_or_authorized
  type: poster
patch:
  region: large_top_headline
  old_text: "OPEN LATE"
  new_text: "OPEN DAILY"
preserve:
  - illustration
  - people
  - border
  - background
  - crop
  - all_other_text
  - print_texture
acceptance:
  exact_new_string: true
  old_string_absent: true
  unrelated_copy_unchanged: true

Use a source large enough to read at 100% zoom. If the text is tiny, curved around an object, heavily occluded, or repeated several times, split the task into separate patches.

Current workspace contract

Open the exact scene-text editor. On July 29, 2026 it showed GPT Image 2, a Poster headline preset, a prefilled exact-replacement prompt, required image URLs, optional mask input, Image Size Auto, Public visibility, and a 6-credit estimate. Required uploads lead through sign-in. The number can change after you supply the source, mask, size, or other settings, so use the final live estimate.

Step 1: quote both strings

Do not write “change the headline.” Quote the source and replacement literally:

Edit only the large top headline. Replace the exact visible text "OPEN LATE" with "OPEN DAILY".

Quotes turn an aesthetic request into a testable assertion.

Step 2: protect the rest of the image

Add the rendering contract:

Match the existing type style, weight, color, alignment, spacing, print texture, and perspective. Preserve the illustration, people, border, background, crop, and every other word. Do not redesign the poster or add text.

If the editor exposes a mask after upload, paint only the target line plus a small context margin. A mask that covers half the poster silently expands the model's permission to redraw it.

Step 3: run a regression check

OCR can catch string failures, but it cannot prove visual fidelity. Combine machine and manual checks:

export function validateTextPatch({ ocrBefore, ocrAfter, oldText, newText }) {
  const normalize = (s) => s.toUpperCase().replace(/\s+/g, " ").trim();
  const before = normalize(ocrBefore);
  const after = normalize(ocrAfter);
  return {
    sourceFound: before.includes(normalize(oldText)),
    replacementFound: after.includes(normalize(newText)),
    oldTextRemoved: !after.includes(normalize(oldText)),
  };
}

Then compare at 100%:

baseline and alignment;
letter spacing and capitalization;
perspective and surface texture;
faces, products, logos, borders, and every unrelated word.

Troubleshooting

The whole poster changes. Tighten the mask and repeat “edit only.” Remove stylistic adjectives unrelated to the replacement.

The spelling is almost right. Shorten the replacement, keep exact quotes, and generate one patch at a time. For compliance-critical copy, rebuild the line in a normal design tool instead of trusting a raster render.

Other text mutates. Name every protected region and run a visual diff. If several lines changed, reject the output even when the target headline is correct.

The type looks pasted on. Ask for matching perspective, local contrast, grain, shadow, and print texture—not merely the same font.

Limitations

The result is a raster image, not recovered editable type. AI cannot reliably identify an exact font, preserve brand artwork, or guarantee legal accuracy. Never change invoices, IDs, certificates, evidence, safety labels, or someone else's copyrighted design to mislead. Model availability, credits, size options, and Public visibility may change.

When the patch contract is narrow and reviewable, replace the exact string and run the regression checklist.

A Practical Guide to Iterating on AI Images Without Losing the Original Intent

Voor AI — Tue, 28 Jul 2026 11:06:56 +0000

AI image work usually gets harder after the first generation. The initial prompt may produce a useful direction, but the second and third iterations can quietly change the subject, framing, or visual hierarchy.

A reliable workflow treats every revision as a controlled experiment.

1. Keep a short visual brief

Before editing, write down the parts that must not change:

the main subject and its pose
the camera angle and crop
the dominant light direction
the intended use, such as a product card or a social cover
any text that must remain readable

This brief becomes the reference for every later prompt. It also makes it easier to compare two versions without relying on memory.

2. Separate the change from the constraint

A useful edit prompt has two parts. First describe the single change you want, such as replacing the background or adjusting the color palette. Then state what should remain untouched.

For example:

Replace the background with a quiet studio gradient. Keep the product silhouette, camera angle, label placement, and shadow direction unchanged.

This is more predictable than adding several unrelated changes in one request. If the result misses the brief, you know which variable to revise.

3. Use references for consistency

When an image needs to stay close to an existing design, provide the reference image and describe the relationship between the reference and the new output. References are especially helpful for packaging, character appearance, recurring props, and brand colors.

For a practical multimodal workflow, the FLUX 3 AI image and video generator is one option for moving from a rough visual brief to an editable result. The important part is not the tool name; it is keeping the input, revision, and review steps explicit.

4. Review at the final delivery size

A draft can look convincing at full size and fail in the place where it will actually be used. Check the image at its target size:

confirm that small text is legible
check the crop on mobile
inspect edges around products and people
compare the contrast against the surrounding page
export a clean version instead of repeatedly compressing the same file

5. Keep a simple iteration log

For repeatable work, record the prompt change, the reference used, and the reason a version was accepted or rejected. This prevents teams from circling back to an earlier mistake and makes successful prompt patterns easier to reuse.

The goal is not to generate the largest number of variations. It is to make each iteration answer a clear visual question while preserving the original intent.

A Practical Shot-Planning Workflow for AI Video With Dialogue and Sound Direction

Voor AI — Tue, 28 Jul 2026 09:37:48 +0000

AI video tools are getting better at producing attractive clips, but a polished result still depends more on planning than on a single clever prompt. When a short demo needs dialogue, ambience, and a visual beat to land at the same time, it helps to treat the generation brief like a small production document.

This workflow is useful for product demos, social clips, explainers, and storyboards.

1. Start with the viewer's job

Before writing a prompt, write one sentence describing what the viewer should understand or feel after the shot. For example:

The viewer should see the product turn a rough idea into a finished result, and understand that the workflow is quick enough to try.

This keeps the shot from becoming a collection of unrelated visual effects. If the viewer's job is unclear, the prompt usually becomes overloaded with adjectives.

2. Write a shot contract

A shot contract is a compact checklist:

subject and action
camera distance and movement
setting and lighting
aspect ratio and approximate duration
dialogue or on-screen text
ambience and sound direction
the transition into the next shot

The contract does not need to be poetic. It needs to be testable. “A calm close-up of the interface while the cursor completes the final step” is easier to evaluate than “make it cinematic and inspiring.”

3. Separate visual direction from audio direction

Visual instructions and audio instructions solve different problems. Put them in separate paragraphs or labeled sections so the model can resolve conflicts more reliably.

Visual direction

medium close-up
slow push-in
neutral desk lighting
keep the main interface area readable
leave negative space for a caption

Audio direction

a short, clear voice line
light room tone
a restrained confirmation sound at the end
no music competing with the spoken instruction

This separation also makes revisions faster. If the visuals work but the voice feels rushed, you can adjust the audio direction without rewriting the entire shot.

4. Use references and keyframes deliberately

A reference image should answer a specific question: composition, character appearance, color, or interface state. If it is meant to control composition, say so. If it is only a mood reference, say that instead.

Keyframes are most useful when a transition matters. Define the starting state and the ending state in plain language, then describe the motion between them. Avoid asking a single short clip to introduce a character, explain a product, change locations, and deliver a punchline all at once.

5. Make a cheap first pass

The first generation is a test of the contract, not the final export. Check:

Is the subject doing the intended action?
Is the camera movement understandable?
Is the dialogue short enough to fit?
Does the ambience support the scene?
Does the final frame leave a clean handoff to the next shot?

If two or more answers are “no,” revise the brief before adding more visual detail. A shorter, clearer prompt usually beats a longer prompt full of rescue instructions.

6. Review sync as a separate pass

Watch the clip once without sound, then listen once without looking at the screen. Finally, watch and listen together. This catches different classes of problems:

visual action starts before the spoken line
a sound effect arrives after the action it describes
ambience changes abruptly between shots
captions remain on screen after the sentence ends

A browser-based FLUX 3 video workflow can be useful here because the visual brief, references, keyframes, and sound direction can be kept together while iterating.

7. Keep a reusable handoff template

For recurring work, save a small template with these fields:

goal
audience
shot length
visual action
camera
dialogue
ambience
sound effect
negative constraints
acceptance checks

The template turns each new clip into an editing task instead of a blank page. It also makes collaboration easier because another person can see exactly which part of the brief needs revision.

The best AI video results are rarely the result of adding more adjectives. They come from making the intended action, timing, and sound easy to verify. Plan the shot, test the contract, and revise the smallest failing part.