Creatify-Boreal Prompt Recipes: Copy-Paste Prompts for UGC and Product Video

Why Prompt Recipes Beat One-Off Prompts

Every team that generates UGC or product video with creatify-boreal eventually hits the same wall: a prompt that produced a great clip last week behaves differently the moment you change a word, swap a product, or hand it to a teammate. One-off prompting feels fast until you have twenty clips and no idea which instruction produced the good one.

A prompt recipe fixes this by treating prompts like code. Instead of a single tangled paragraph, you keep a parameterized template with named slots — one for the goal, one for the subject, one for framing, one for style, one for constraints. You fill the slots per product and per campaign, and the structure stays constant.

The benefits compound quickly:

• Reproducibility. Two people filling the same template get comparable output, because the scaffolding is shared and only the variables differ.
• Versionability. A recipe can live in your repo, get reviewed in a pull request, and be tagged with the clips it produced.
• Testability. When you A/B test hooks, you change one slot at a time instead of rewriting the whole prompt and losing the signal.

This is the shift from ad-hoc experimentation to a repeatable workflow: recipes as the unit of authorship, creatify-boreal as the rendering engine behind them. The rest of this guide walks through concrete recipes for the three blocks that drive most UGC and product video — hooks, avatar framing, and product shots — then shows how to chain and validate them.

Anatomy of a Creatify-Boreal Prompt Recipe

Before writing recipes, agree on the parts. A well-formed creatify-boreal recipe has five composable blocks, each with explicit variables. The exact wording is yours; the structure is what makes it reusable.

1. Goal block

One sentence stating what the clip must accomplish and for whom. This anchors every downstream choice.

Goal: a {duration}-second {format} clip that {objective} for {audience}.

2. Subject block

Who or what is on screen. For avatar-led clips this is the presenter; for product shots it is the item.

Subject: {presenter_or_product}, {key_trait}.

3. Framing block

Camera distance, angle, and composition. Keep this separate from style so you can reuse a framing across many looks.

Framing: {shot_size}, {camera_angle}, subject positioned {placement}.

4. Style block

The visual and tonal register — lighting, pacing, energy level, aesthetic reference described in plain language.

Style: {lighting}, {pacing}, {tone}.

5. Constraint block

Hard rules the output must respect: aspect ratio, on-screen text policy, things to avoid, brand-safety boundaries.

Constraints: {aspect_ratio}; {text_policy}; avoid {avoid_list}.

A full recipe is just these blocks stacked, with variable slots marked so they are obvious to fill. Two practical rules keep recipes healthy. First, never let one block bleed into another — if framing starts describing tone, you have lost the ability to swap tone independently. Second, keep variable names stable across your library so a script can populate them consistently when you scale.

Recipe: Hook Scripts That Stop the Scroll

The hook is the first beat of any UGC clip and the most common reason a clip underperforms. Isolating it as its own recipe lets you test openings without re-specifying the entire video.

Copy-paste template:

Goal: a {hook_seconds}-second opening that makes {audience} stop scrolling and want the next line.
Subject: a {presenter_persona} speaking directly to camera, energy {energy_level}.
Framing: {shot_size} selfie-style, eye level, subject centered.
Style: {lighting}, fast pacing, conversational tone.
Constraints: {aspect_ratio}; hook line spoken within the first second;
on-screen text: {text_hook}; avoid {avoid_list}.

Hook line: "{hook_script}"
Hook type: {hook_type}  # e.g. problem-callout, curiosity, result-first, contrarian

Swap these variables per product: presenter_persona, hook_type, hook_script, and text_hook. Everything else is the reusable shell.

A few things this pattern buys you:

• One variable, one test. Change only hook_type between runs and you learn which opening archetype lands for a given audience, rather than guessing.
• Script stays separate from direction. The spoken line lives in its own slot, so a copywriter can rewrite it without touching framing or style.
• Text hooks are explicit. Caption-style text is a common silent failure point, so the recipe forces you to declare it and how it should appear.

Keep a small library of hook_type values and rotate them across products. After a few batches you will know which archetypes suit which categories, and the library becomes a genuine asset.

Recipe: Avatar Framing and Delivery

Avatars are where consistency earns its keep: a viewer should recognize the same presenter across a series, which means framing and delivery must be repeatable rather than re-imagined each time.

Copy-paste template:

Goal: a {duration}-second presenter segment with consistent on-camera delivery.
Subject: {presenter_persona}, {wardrobe}, {expression}.
Framing: {shot_size} at {camera_angle}, subject at {placement}, headroom {headroom}.
Style: {lighting}, {pacing} delivery, {tone}.
Constraints: {aspect_ratio}; gaze to {gaze_target}; hands {hand_behavior};
avoid {avoid_list}.

Delivery notes: speak at {speech_pace}; emphasize {emphasis_phrases}.

The knobs that control it

• shot_size and camera_angle define the visual signature of the series. Lock these across a campaign and only change them when you want a deliberate format shift.
• placement and headroom keep the head in frame and the composition stable, which matters most when clips get cropped into vertical feeds.
• gaze_target decides whether the presenter addresses the lens or something off-camera; inconsistent gaze is a subtle but strong signal that a series was stitched together.
• speech_pace and emphasis_phrases shape delivery without touching the script, so a single persona can carry multiple script variants.

Treat presenter_persona, wardrobe, and expression as the per-campaign variables and the rest as the fixed shell. When you need a second presenter, copy the recipe and change only those three slots — the framing language carries over intact.

Recipe: Product-Shot Cues

Product shots carry the claim the hook promises. This recipe targets the item itself, describing it precisely enough that visuals stay on-brand across many generations.

Copy-paste template:

Goal: a {duration}-second product shot that highlights {feature_to_showcase}.
Subject: {product_name}, {product_state}, {distinctive_detail}.
Framing: {shot_size} of the product, {camera_angle}, product {placement} in frame.
Style: {lighting}, {surface_context}, {motion}.
Constraints: {aspect_ratio}; label legible: {label_rule}; color fidelity {color_rule};
avoid {avoid_list}.

Cue: {cue_type}  # e.g. rotation, reveal, close-up detail, in-hand demo

Describing cues that stay on-brand

Cues are the small directives that make a product shot feel intentional. Three that travel well:

• cue_type selects the motion metaphor — a slow rotation reads as a hero shot, a close-up detail reads as a feature proof. Keep the vocabulary small and consistent.
• distinctive_detail names the single feature that must be visible. Forcing one detail per shot prevents the camera from wandering.
• label_rule and color_rule are explicit brand-safety constraints. Stating that labels stay legible and colors stay true up front saves re-runs later.

Because product_state and surface_context are variables, the same recipe works whether the item is held, on a shelf, or mid-demo. Swap those, keep the framing and cue vocabulary, and your product library stays visually coherent.

Composing Recipes Into a Full Video Workflow

Individually useful recipes become a pipeline when you sequence them. A typical UGC-style clip is three beats: hook, presenter body, product proof. Each maps to one recipe, and all three share a single variable source.

The chain

1. Resolve variables once. Keep a per-product config — persona, audience, hook type, feature to showcase, aspect ratio — and feed it to every recipe. This is what makes the chain composable: the hook and the product shot agree on the same product and audience because they read the same values.
2. Generate the hook with the hook recipe to lock the opening direction.
3. Generate the presenter segment with the avatar recipe, reusing the same persona and framing shell.
4. Generate the product shot with the product recipe, pointing cue_type at the feature the hook promised.
5. Assemble and review the beats as one sequence, checking that the promise in the hook is actually delivered by the product shot.

config = { persona, audience, hook_type, hook_script, feature, aspect_ratio, ... }
beat_1 = hook_recipe(config)
beat_2 = avatar_recipe(config)
beat_3 = product_recipe(config)
video  = assemble([beat_1, beat_2, beat_3])

Practical rules for chaining

• Shared framing shell. Derive all three recipes from the same framing vocabulary so beats cut together without jarring size or angle jumps.
• One promise. The hook's claim should be the exact feature the product shot showcases; a mismatch reads as a bait-and-switch.
• Keep beats independently re-runnable. If only the product shot is weak, regenerate that beat rather than the whole clip.

When the chain is stable, generation becomes a function of config: change the config, re-run, get a coherent new clip.

Iterating and Validating Prompts at Scale

A recipe is only production-ready after it has survived a few controlled loops. The goal is to earn confidence cheaply before you spend on volume.

A versioning loop that works

• Store recipes in the repo next to the code that calls them, with stable filenames and a changelog line per revision.
• Commit the config, not just the prompt. A recipe plus the variables it ran with is the true unit of record; without the config, a past result is not reproducible.
• Tag outputs by recipe version. When a clip is approved, note which version produced it. This is how you trace quality regressions later.

Small-batch validation

Before any bulk run, generate a small batch — a handful of clips per recipe variant — and score them against explicit criteria: does the hook land in the first second, is framing consistent, is the promised feature visible, are constraints respected? Compare variants that differ in exactly one slot so the signal is attributable.

Only promote a recipe to bulk generation when:

• multiple runs on the small batch hold up, not just one lucky clip;
• the variation across runs is acceptable for your brand;
• the config that produced it is committed and tagged.

When to stop iterating

Diminishing returns hit fast. If three rounds of single-slot changes move quality little, the limit is usually the brief, not the prompt — revisit the goal block or the config instead of grinding on wording. Freeze the recipe, tag it, and move the experimentation up a level.

Run this loop and your creatify-boreal library stops being a folder of lucky prompts and becomes a maintained, reviewable system you can scale with confidence.