September 1, 2026AIExplore

How to Control Style and Aesthetics in Luma

Steer Dream Machine looks with @style references, lighting recipes, and Modify strengths so campaigns share one visual DNA.

Luma

Visual style control in Dream Machine uses @style references, explicit lighting and color language, and Modify image roles. Official best practices: upload an image, type @style, then describe the new subject with that visual DNA. In Modify Video, Style uses the image as a style reference while Start Frame extends motion from that frame. Overview: /explore/luma.

This guide covers the workflow in detail. Related Luma articles: /blog/how-to-create-consistent-characters-in-luma, /blog/how-to-build-campaigns-and-reusables-in-luma, /blog/how-to-edit-and-refine-videos-iteratively-in-luma.

When this workflow is the right job

Use @style when palette, texture, and lighting mood must transfer to new subjects. Prefer @character for identity. Prefer Modify when a clip needs a conversational restyle.

Step by step workflow

1. Pick a style reference

Choose an image that shows the grade, texture, or lighting you want, not necessarily the same subject.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Style ref QA [ ] Palette clear [ ] Lighting mood clear [ ] Texture readable [ ] Not overloaded with conflicting subjects. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Style ref QA [ ] Palette clear [ ] Lighting mood clear [ ] Texture readable [ ] Not overloaded with conflicting subjects" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure luma specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Style ref QA [ ] Palette clear [ ] Lighting mood clear [ ] Texture readable [ ] Not overloaded with conflicting subjects" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

2. Prompt with @style

State the new subject clearly after @style.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Minimalist watercolor landscape with paper texture and desaturated greens. Subject: bicycle leaning on a cafe wall, afternoon shade.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Minimalist watercolor landscape with paper texture and desaturated greens. Subject: bicycle leaning on a cafe wall, afternoon shade." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Minimalist watercolor landscape with paper texture and desaturated greens. Subject: bicycle leaning on a cafe wall, afternoon shade." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

3. Lock winning keywords

Reuse film stock, color, and light phrases that work across the board.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Style constants Shot on 35mm film Muted earth tones Soft window light from left Shallow depth of field. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Style constants Shot on 35mm film Muted earth tones Soft window light from left Shallow depth of field" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Style constants Shot on 35mm film Muted earth tones Soft window light from left Shallow depth of field" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

4. Modify when close

Use Adhere for subtle restyle, Flex for stronger change, Reimagine for larger world shifts on paid Modify.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Modify with Flex: Make the colors warmer and add more trees. Keep camera path.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Modify with Flex: Make the colors warmer and add more trees. Keep camera path." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Modify with Flex: Make the colors warmer and add more trees. Keep camera path." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Practical @style and aesthetic prompts

Watercolor bike

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Minimalist watercolor look with paper texture and desaturated greens. Subject: bicycle leaning on a cafe wall, afternoon shade.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Minimalist watercolor look with paper texture and desaturated greens. Subject: bicycle leaning on a cafe wall, afternoon shade." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Minimalist watercolor look with paper texture and desaturated greens. Subject: bicycle leaning on a cafe wall, afternoon shade." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

35mm product

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Soft film still with gentle grain. Subject: matte skincare bottle on wet stone, warm natural light, muted earth tones.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Soft film still with gentle grain. Subject: matte skincare bottle on wet stone, warm natural light, muted earth tones." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Soft film still with gentle grain. Subject: matte skincare bottle on wet stone, warm natural light, muted earth tones." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Noir street

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style High contrast noir lighting. Subject: empty alley with a single street lamp, light rain, locked wide shot.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style High contrast noir lighting. Subject: empty alley with a single street lamp, light rain, locked wide shot." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style High contrast noir lighting. Subject: empty alley with a single street lamp, light rain, locked wide shot." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Pastel studio

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Pastel studio still life grade. Subject: ceramic vase with dried flowers, soft wrap light, clean backdrop.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Pastel studio still life grade. Subject: ceramic vase with dried flowers, soft wrap light, clean backdrop." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Pastel studio still life grade. Subject: ceramic vase with dried flowers, soft wrap light, clean backdrop." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Documentary kitchen

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Handheld documentary kitchen look. Subject: hands kneading dough, warm practicals, gentle movement.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Handheld documentary kitchen look. Subject: hands kneading dough, warm practicals, gentle movement." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Handheld documentary kitchen look. Subject: hands kneading dough, warm practicals, gentle movement." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Anime skyline

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Clean anime city dusk palette. Subject: quiet rooftop with hanging laundry, soft wind, slow pan.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Clean anime city dusk palette. Subject: quiet rooftop with hanging laundry, soft wind, slow pan." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Clean anime city dusk palette. Subject: quiet rooftop with hanging laundry, soft wind, slow pan." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Editorial fashion

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Editorial fashion still with cool rim light. Subject: coat on a stand, slow orbit, minimal set.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Editorial fashion still with cool rim light. Subject: coat on a stand, slow orbit, minimal set." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Editorial fashion still with cool rim light. Subject: coat on a stand, slow orbit, minimal set." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Nature macro

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Macro nature documentary grade. Subject: dew on a leaf, locked camera, soft morning light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Macro nature documentary grade. Subject: dew on a leaf, locked camera, soft morning light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Macro nature documentary grade. Subject: dew on a leaf, locked camera, soft morning light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Retro kitchen

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Warm retro kitchen print look. Subject: toaster and mug on laminate counter, soft morning window light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Warm retro kitchen print look. Subject: toaster and mug on laminate counter, soft morning window light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Warm retro kitchen print look. Subject: toaster and mug on laminate counter, soft morning window light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Brutalist lobby

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Cool brutalist architecture still. Subject: concrete lobby with a single bench, slow push in.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Cool brutalist architecture still. Subject: concrete lobby with a single bench, slow push in." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Cool brutalist architecture still. Subject: concrete lobby with a single bench, slow push in." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Painted portrait mood

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Oil painting texture and soft chiaroscuro. Subject: empty chair by a window, dust in light, static shot.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Oil painting texture and soft chiaroscuro. Subject: empty chair by a window, dust in light, static shot." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Oil painting texture and soft chiaroscuro. Subject: empty chair by a window, dust in light, static shot." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Clean ecommerce

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Bright ecommerce catalog light. Subject: shoe on seamless white, slow turntable rotation.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Bright ecommerce catalog light. Subject: shoe on seamless white, slow turntable rotation." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Bright ecommerce catalog light. Subject: shoe on seamless white, slow turntable rotation." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Fog forest

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Soft fog forest still with cool greens. Subject: narrow path between trees, gentle forward move.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Soft fog forest still with cool greens. Subject: narrow path between trees, gentle forward move." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Soft fog forest still with cool greens. Subject: narrow path between trees, gentle forward move." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Neon rainy

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Neon reflection night grade. Subject: wet crosswalk, soft rain, static medium.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Neon reflection night grade. Subject: wet crosswalk, soft rain, static medium." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Neon reflection night grade. Subject: wet crosswalk, soft rain, static medium." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Desert heat

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Hot desert film still with hard sun. Subject: lone road sign, heat haze, slow push.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Hot desert film still with hard sun. Subject: lone road sign, heat haze, slow push." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Hot desert film still with hard sun. Subject: lone road sign, heat haze, slow push." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Nordic cabin

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Quiet Nordic interior grade. Subject: wood cabin table with tea, soft overcast window light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Quiet Nordic interior grade. Subject: wood cabin table with tea, soft overcast window light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Quiet Nordic interior grade. Subject: wood cabin table with tea, soft overcast window light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Sports grit

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Gritty sports documentary grade. Subject: empty stadium tunnel, cool practicals, slow tracking.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@style Gritty sports documentary grade. Subject: empty stadium tunnel, cool practicals, slow tracking." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@style Gritty sports documentary grade. Subject: empty stadium tunnel, cool practicals, slow tracking." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

How to improve style control

Always name the new subject when using @style. Style alone without subject invents randomly.

Avoid stacking conflicting style anchors in one line.

In Modify, remember Style versus Start Frame roles so you do not extend from the wrong intent.

Adhere for light restyle. Flex for meaningful change. Reimagine for larger world changes.

Save prompts that hit brand look into a reusable library.

Keep lighting direction language stable across a campaign.

If palette drifts, swap the @style image before rewriting the whole prompt.

Draft lower cost explores, then finalize resolution once style locks.

Combine @style with one camera move so aesthetics and motion do not fight.

For product truth, do not let style prompts invent new packaging graphics.

Use boards to keep a style exploration separate from final campaign clips.

When stakeholders say more premium, translate into concrete light and texture words.

Prompting guidance that holds up in review

Lead with @style, then a clear Subject line so the model knows what to render.

Film stock and lens language often beats abstract cinematic alone.

Describe palette with concrete color families: muted earth tones, cool blues, warm tungsten.

Separate style exploration boards from delivery boards.

Pair style constants with template variables for campaign reuse.

Limitations to respect

Modify Video is available with paid Dream Machine subscriptions on web and iOS per official Modify docs.

Video to video credit costs appear per second by model and resolution on the pricing page.

Style transfer will not magically fix a broken composition.

Conflicting style anchors dilute the look instead of blending cleanly.

Field tips from real boards

Test the same subject under two style refs to learn which DNA transfers cleanly.

Modify after a good composition rather than restyling a broken shot.

Document banned looks for the brand as clearly as allowed looks.

Credit plan style explores separately from hero finals.

A style reference should encode grade and texture, not a second subject fighting the prompt.

When palette drifts, swap the @style still before rewriting the entire shot description.

Keep Style versus Start Frame roles distinct in Modify so you do not extend from the wrong intent.

Write banned looks beside allowed looks so freelancers do not invent a parallel brand.

Explore style on a scratch board, then promote winners into the campaign board.

Translate stakeholder words like premium into light direction, material finish, and grain, not vibes alone.

Pair each @style asset with three proven subject prompts so the DNA is stress tested.

Do not restyle a broken composition. Fix motion or framing first, then apply aesthetic DNA.

Credit plan style explores separately from hero finals so experiments do not starve delivery.

Film stock and window light recipes transfer more reliably than abstract mood adjectives.

If two style anchors conflict, pick one reference and delete the other from the prompt.

Document which style refs failed legal review so they never reenter the library.

For style delivery, reject any take that fails a one sentence subject and motion intent test before you queue another credit spend.

A style reference should encode grade and texture, not a second subject.

When palette drifts, swap the @style still before rewriting the shot.

Keep Style versus Start Frame roles distinct in Modify.

Write banned looks beside allowed looks for freelancers.

Explore style on a scratch board, then promote winners.

Translate premium into light direction, material finish, and grain.

Pair each @style asset with three proven subject prompts.

Do not restyle a broken composition. Fix motion first.

Film stock and window light recipes transfer more reliably than mood words.

If two style anchors conflict, pick one and delete the other.

Document which style refs failed legal review.

Build a style kit of three stills: hero grade, night grade, and macro texture. Use them as a set.

When a style ref is too busy, crop it to the lighting and texture region before upload.

Name the subject after @style every time, even if the subject seems obvious from the board.

Avoid stacking anime and documentary anchors in one prompt. Pick a lane.

After a Flex restyle, recheck product geometry before calling the look done.

Keep a changelog of style keywords that won and lost stakeholder review.

Use Adhere when the composition is already brand safe and only the grade is off.

Common mistakes

Using @style without stating the new subject
Conflicting style anchors in one prompt
Confusing Style and Start Frame roles in Modify
Restyling a broken composition instead of fixing motion first
Rewriting brand style constants every asset
Ignoring credit cost of high resolution Modify passes

Related Luma articles: /blog/how-to-create-consistent-characters-in-luma, /blog/how-to-build-campaigns-and-reusables-in-luma, /blog/how-to-edit-and-refine-videos-iteratively-in-luma. Return to /explore/luma for the broader guide set.