September 1, 2026AIExplore

How to Build Campaigns and Reusables in Luma

Build Dream Machine prompt libraries with locked brand constants, swapped variables, and reusable @style and @character references.

Luma

Campaign consistency in Dream Machine comes from reusable templates, locked style constants, and shared @style or @character references. Build templates with shot type, subject variable, setting variable, brand camera style, brand lighting, and brand color. Swap variables, keep constants. Plus plan lists commercial use on the official pricing page. Confirm current terms for your plan. Start at /explore/luma.

This guide covers the workflow in detail. Related Luma articles: /blog/how-to-control-style-and-aesthetics-in-luma, /blog/how-to-create-consistent-characters-in-luma, /blog/how-to-use-luma-dream-machine-for-text-to-video.

When this workflow is the right job

Use this when you produce many SKUs, regions, or formats that must feel like one brand. Prefer single shot experiments when exploring a new look for the first time.

Step by step workflow

1. Write brand constants

Lock camera style, lighting, and color language that should never drift.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Brand constants Camera: static or slow push in (pick one per asset) Light: soft window left Color: muted earth tones Lens: shot on 35mm film. 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 "Brand constants Camera: static or slow push in (pick one per asset) Light: soft window left Color: muted earth tones Lens: shot on 35mm film" 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 "Brand constants Camera: static or slow push in (pick one per asset) Light: soft window left Color: muted earth tones Lens: shot on 35mm film" 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. Add variables

Leave product, surface, and setting as fillable slots.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: TEMPLATE Shot: medium product hero Camera: slow push in Light: soft window left Color: muted earth tones VARIABLE: [PRODUCT] on [SURFACE] Aspect: 9:16. 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 "TEMPLATE Shot: medium product hero Camera: slow push in Light: soft window left Color: muted earth tones VARIABLE: [PRODUCT] on [SURFACE] Aspect: 9:16" 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 "TEMPLATE Shot: medium product hero Camera: slow push in Light: soft window left Color: muted earth tones VARIABLE: [PRODUCT] on [SURFACE] Aspect: 9:16" 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. Attach reusables

Store @style and @character references with the library entry.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Library entry Name: Skincare hero vertical Style ref: brand grade still Character ref: none Aspect: 9:16 Prompt template: .... 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 "Library entry Name: Skincare hero vertical Style ref: brand grade still Character ref: none Aspect: 9:16 Prompt template: ..." 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 "Library entry Name: Skincare hero vertical Style ref: brand grade still Character ref: none Aspect: 9:16 Prompt template: ..." 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. Batch with credit awareness

Explore draft or lower cost variants, then run finals. Document winners.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Batch plan 1) Draft three SKUs at lower cost 2) Pick winners 3) Final resolution renders 4) Save prompts that worked. 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 "Batch plan 1) Draft three SKUs at lower cost 2) Pick winners 3) Final resolution renders 4) Save prompts that worked" 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 "Batch plan 1) Draft three SKUs at lower cost 2) Pick winners 3) Final resolution renders 4) Save prompts that worked" 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 campaign templates

Skincare vertical

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Wide shot of [PRODUCT] on [SURFACE], handheld with gentle movement, warm natural light, muted earth tones with selective color pops, shot on 35mm film, 9:16 vertical social cut.. 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 "Wide shot of [PRODUCT] on [SURFACE], handheld with gentle movement, warm natural light, muted earth tones with selective color pops, shot on 35mm film, 9:16 vertical social cut." 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 "Wide shot of [PRODUCT] on [SURFACE], handheld with gentle movement, warm natural light, muted earth tones with selective color pops, shot on 35mm film, 9:16 vertical social cut." 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.

Sneaker orbit set

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Orbit around [PRODUCT] on concrete, slow steady move, soft daylight, shallow depth of field, product centered, 1:1 feed cut.. 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 "Orbit around [PRODUCT] on concrete, slow steady move, soft daylight, shallow depth of field, product centered, 1:1 feed cut." 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 "Orbit around [PRODUCT] on concrete, slow steady move, soft daylight, shallow depth of field, product centered, 1:1 feed cut." 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.

Food steam hero

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Slow push in on [DISH] on [TABLE], soft restaurant practicals, gentle steam, shallow depth of field, 16:9.. 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 "Slow push in on [DISH] on [TABLE], soft restaurant practicals, gentle steam, shallow depth of field, 16:9." 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 "Slow push in on [DISH] on [TABLE], soft restaurant practicals, gentle steam, shallow depth of field, 16:9." 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.

Apparel settle

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Static medium of [GARMENT] on [FORM], fabric settles softly, soft studio wrap light, brand muted palette.. 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 "Static medium of [GARMENT] on [FORM], fabric settles softly, soft studio wrap light, brand muted palette." 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 "Static medium of [GARMENT] on [FORM], fabric settles softly, soft studio wrap light, brand muted palette." 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.

Cafe lifestyle

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character [TALENT] holds [PRODUCT] at a cafe table, medium lock off, morning window light, brand warm grade.. 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 "@character [TALENT] holds [PRODUCT] at a cafe table, medium lock off, morning window light, brand warm grade." 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 "@character [TALENT] holds [PRODUCT] at a cafe table, medium lock off, morning window light, brand warm grade." 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.

Style locked landscape

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @style Brand watercolor grade. Subject: [PRODUCT] on a cafe ledge, afternoon shade, 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 Brand watercolor grade. Subject: [PRODUCT] on a cafe ledge, afternoon shade, 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 Brand watercolor grade. Subject: [PRODUCT] on a cafe ledge, afternoon shade, 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.

Night neon variant

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Static medium of [PRODUCT] on wet stone, neon reflections, soft rain, brand night palette, 9:16.. 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 "Static medium of [PRODUCT] on wet stone, neon reflections, soft rain, brand night palette, 9:16." 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 "Static medium of [PRODUCT] on wet stone, neon reflections, soft rain, brand night palette, 9:16." 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.

Macro detail

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Macro lock off on [PRODUCT] texture, soft side light, shallow depth of field, no new logos.. 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 "Macro lock off on [PRODUCT] texture, soft side light, shallow depth of field, no new logos." 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 "Macro lock off on [PRODUCT] texture, soft side light, shallow depth of field, no new logos." 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.

Unboxing settle

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Top down static of [PRODUCT] in open box, soft overhead, materials settle, clean ecommerce mood.. 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 "Top down static of [PRODUCT] in open box, soft overhead, materials settle, clean ecommerce mood." 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 "Top down static of [PRODUCT] in open box, soft overhead, materials settle, clean ecommerce mood." 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.

Seasonal swap

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Wide shot of [PRODUCT] on [SURFACE], [SEASON LIGHT], muted earth tones, slow push in, 16:9.. 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 "Wide shot of [PRODUCT] on [SURFACE], [SEASON LIGHT], muted earth tones, slow push in, 16:9." 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 "Wide shot of [PRODUCT] on [SURFACE], [SEASON LIGHT], muted earth tones, slow push in, 16:9." 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.

Regional overlay note

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Generate hero motion only. Keep frame clean for regional text overlays in post. Soft window left, 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 "Generate hero motion only. Keep frame clean for regional text overlays in post. Soft window left, 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 "Generate hero motion only. Keep frame clean for regional text overlays in post. Soft window left, 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.

Trio SKU lock

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Same camera slow push in and soft window left for three SKUs: [A], [B], [C]. Swap product only.. 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 "Same camera slow push in and soft window left for three SKUs: [A], [B], [C]. Swap product only." 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 "Same camera slow push in and soft window left for three SKUs: [A], [B], [C]. Swap product only." 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.

Loop ambient brand

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Looping video of [PRODUCT] with gentle steam or light play, seamless, locked camera, brand warm grade.. 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 "Looping video of [PRODUCT] with gentle steam or light play, seamless, locked camera, brand warm grade." 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 "Looping video of [PRODUCT] with gentle steam or light play, seamless, locked camera, brand warm grade." 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.

Board naming

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Board: Campaign Spring Heroes Clip naming: SKU_aspect_move_v1. 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 "Board: Campaign Spring Heroes Clip naming: SKU_aspect_move_v1" 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 "Board: Campaign Spring Heroes Clip naming: SKU_aspect_move_v1" 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.

Modify brand warm

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 Adhere: Warm toward brand grade. Keep product color exact. No new props.. 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 Adhere: Warm toward brand grade. Keep product color exact. No new props." 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 Adhere: Warm toward brand grade. Keep product color exact. No new props." 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.

End card still

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Static wide of [PRODUCT] centered, soft brand light, clean negative space for end card type in post.. 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 "Static wide of [PRODUCT] centered, soft brand light, clean negative space for end card type in post." 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 "Static wide of [PRODUCT] centered, soft brand light, clean negative space for end card type in post." 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.

Prompt library card

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Name: Hero push 9:16 Constants: slow push in, soft window left, muted earth tones, 35mm Variables: PRODUCT, SURFACE Refs: style_brand_v2. 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 "Name: Hero push 9:16 Constants: slow push in, soft window left, muted earth tones, 35mm Variables: PRODUCT, SURFACE Refs: style_brand_v2" 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 "Name: Hero push 9:16 Constants: slow push in, soft window left, muted earth tones, 35mm Variables: PRODUCT, SURFACE Refs: style_brand_v2" 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 run campaigns without drift

Document prompts that repeatedly succeed for the brand.

Generate regional variants by changing overlay copy in post when typography must be exact.

Keep lighting and composition language stable while swapping product variables.

Organize libraries by client, content type, platform, and shot category.

Explore draft or lower cost variants before committing credits to final resolution.

Front load brand critical details early in the prompt.

Plus lists commercial use on official pricing. Confirm your plan terms before delivery.

Do not rewrite prompts from scratch for every cutdown.

Inconsistent lighting language between hero and social variants breaks campaigns.

Store @style and @character assets beside templates.

Name boards and clips so editors can find winners fast.

Batch SKUs that share a motion recipe to reduce decision fatigue.

Prompting guidance that holds up in review

Write templates with constants first and variables in brackets.

Offer separate templates for orbit versus push in instead of mixing moves.

Keep aspect ratio in the template so social and hero cuts do not drift.

Attach reference asset names in the library card, not only in chat memory.

Train collaborators on the six part framework so freelance prompts still match.

Limitations to respect

Credits vary widely by model and resolution. Campaign batches need a forecast from the live pricing table.

Exact multi language typography is safer in post than in generation.

Commercial use depends on plan terms. Confirm before client delivery.

A template cannot rescue a bad still or a contradictory brief.

Field tips from real boards

Review product accuracy before publishing any Modify pass.

Keep a banned list: looks and phrases that failed brand review.

Credit plan for explore versus final so teams do not burn the month on drafts.

When a template fails on a new SKU, fix one variable at a time.

Templates fail when freelancers rewrite constants. Protect lighting and camera language as locked fields.

Put aspect ratio in the template so 9:16 and 16:9 cuts do not silently diverge.

Regional copy belongs in post overlays when typography must be exact across languages.

Batch SKUs that share a motion recipe in one session so decisions stay consistent.

Name boards and clips with SKU, aspect, and move so editors can find winners without archaeology.

Keep explore credits and final credits as separate budgets inside the campaign plan.

Attach @style and @character asset names on the library card, not only in chat history.

When a template fails on a new SKU, change one variable at a time and log the fix.

Offer separate templates for orbit and push in rather than mixing moves inside one card.

Commercial use depends on plan terms. Confirm before client delivery, especially on free or lite contexts.

A banned look list prevents recycled failures from reentering the prompt library.

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

Templates fail when freelancers rewrite constants. Protect lighting and camera fields.

Put aspect ratio in the template so social and hero cuts do not diverge.

Regional copy belongs in post overlays when typography must be exact.

Batch SKUs that share a motion recipe in one session.

Name boards and clips with SKU, aspect, and move.

Keep explore credits and final credits as separate budgets.

Attach @style and @character asset names on the library card.

When a template fails on a new SKU, change one variable at a time.

Offer separate templates for orbit and push in.

Confirm commercial use terms for the active plan before client delivery.

A banned look list prevents recycled failures from reentering the library.

Version your prompt library like code. Note which constants changed and why.

Hero, social, and end card templates should share lighting while differing in framing.

Do not let regional teams invent new camera language for the same SKU.

Attach example winner clips to each library card so freelancers see the target.

Forecast credits from the live pricing table by model and resolution before kickoff.

Keep free tier exploration separate from client delivery boards when watermarks or limits apply.

A weekly library review should retire failed templates instead of letting them linger.

Common mistakes

Rewriting prompts from scratch for every cutdown
Inconsistent lighting language between hero and social variants
Skipping a prompt library when producing dozens of SKUs
Putting exact multi language typography only in the model
Mixing camera moves inside one template
Ignoring commercial use terms for the active plan

Related Luma articles: /blog/how-to-control-style-and-aesthetics-in-luma, /blog/how-to-create-consistent-characters-in-luma, /blog/how-to-use-luma-dream-machine-for-text-to-video. Return to /explore/luma for the broader guide set.