---
name: cold-video
description: Create a short personalized prospecting video using a paid external video service such as Runway or fal.ai, built around one buyer persona and a verified product capability. Use for cold videos, video cold emails and prospect-specific solution videos. Prepare the story, provider prompts and cost estimate before paid generation, then assemble and verify the video. Sending is separate. For interactive HTML use Persona Demo.
---

# Cold Video

Make a short video in which the prospect recognizes their team's work and sees a credible future with the seller's solution. Personalization means relevant role, situation, vocabulary and workflow, not just a logo or first-name overlay.

This skill is independent of Persona Demo. It can start from product/prospect URLs, a sales brief, a script, actual captures, or an existing Persona Demo storyboard. Do not require a deck first. Do not build an interactive presentation when the user asks for a finished video.

**Production model:** the user supplies access to a paid external video service, such as Runway or fal.ai. This skill supplies the sales story, generation direction, assembly and quality checks; it does not include provider credits or an authenticated connector. Local planning is available before connecting or paying. Provider generation and final assembly are separate stages.

## Establish the story

Use available context first. Resolve seller/product, buyer role, one concrete scenario, supported capability and intended next action. If missing, ask the highest-value question and continue research that does not depend on the answer. Prefer one persona and one incident for the first draft.

Read supplied websites with available tools and save dated source URLs for factual claims. Separate publicly documented business context, user-confirmed context and illustrative assumptions. A prospect website cannot establish their private systems, employee frustrations or buying intent. Do not imply a fictional persona is a real employee. If evidence is thin, use conditional language and label the scenario rather than inventing research.

Default to roughly 30–60 seconds, adapting to the user's goal. Open on a recognizable event, show the obstacle briefly, spend most of the runtime on the future workflow, and end with one useful question or specific invitation. A workable 45-second rhythm is event (0–7), obstacle (7–13), product-enabled action (13–30), handoff/result (30–39), question (39–45). This is a starting point, not a fixed template.

Keep the claim chain explicit: product capability → observable action → plausible immediate result. Quantified time savings, revenue, named customer results and ROI require supporting evidence. Avoid fabricated prospect quotations and surveillance-like opening lines. Do not call a generic logo swap a custom scenario.

## Prepare a renderable brief

Read [production and quality](https://greenfield.tools/skills/cold-video/references/production.md). Write the brief using `assets/tim-video.json` as a format example. It is wholly fictional and not evidence for a real product. Run:

```sh
python3 <skill-dir>/scripts/prepare_video.py --input <brief.json> --output <new-output-dir>
```

This validates timing/evidence links and produces `storyboard.html`, `render-spec.json`, `provider-plan.json`, `narration.txt`, `captions-draft.vtt`, and `poster.svg`. These are production inputs, **not a finished video**. If adapting Persona Demo, explicitly rewrite its scene captions/narration for an independent viewer and remove speaker notes; do not just accelerate a live deck.

Create local drafts without inserting a mandatory approval stop. Present a concrete storyboard/script when user review is needed, particularly before paid generation or external disclosure.

## Produce the video

Read [paid providers](https://greenfield.tools/skills/cold-video/references/providers.md). Resolve the user's provider preference, available authenticated access and budget. Prepare exact prompts, references, shot count, duration, output format, price source/date and a maximum spend including any regeneration allowance. Verify current provider/model pricing. If spend is already authorized within that scope, proceed; otherwise ask for the missing budget approval with this concrete package. Creating or installing this skill does not authorize paid generation. Never ask the user to paste API secrets into chat.

Generate through the chosen provider using its current supported connector, API or authorized browser workflow. Read [Runway](https://greenfield.tools/skills/cold-video/references/runway.md) or [fal.ai](https://greenfield.tools/skills/cold-video/references/fal.md) for the relevant route. Save job IDs and outputs so a timeout cannot trigger a duplicate paid request. Review generated footage before paying for further variants.

Then read [assembly routing](https://greenfield.tools/skills/cold-video/references/engines.md) and select one available renderer. Honor an explicit engine preference. Otherwise prefer the installed HyperFrames workflow for final assembly; read its entrypoint and current core/CLI contracts before authoring. Reuse an existing Remotion project where appropriate. These resources are optional capabilities, not dependencies the skill can assume are installed.

Use actual product captures to demonstrate real interfaces. Use typography, callouts and transitions to connect the human situation to product action. A generated interface is a labeled concept, never proof of a feature. If captures are missing, continue with a labeled diagram/storyboard and report the missing evidence.

Use paid generation for the human/workplace narrative and visual continuity. Compose exact product screens, logos, typography and captions separately so generative footage does not corrupt them. Do not upload private prospect information or imitate a real person without appropriate authorization. If the scenario does not benefit from generated footage, explain that before spending and offer a capture-led video variant.

Finish with a deterministic rendered composition: stable scene order, deliberate timing, readable captions, licensed assets and controlled sound. Audio is optional; the story must work muted. When narration is supplied/generated, retime captions against the actual audio. `captions-draft.vtt` contains estimated scene cues and is not final synchronized caption evidence.

## Verify and deliver

Inspect an actual final render at opening, each transition, product steps and ending; listen through if audio exists. Confirm duration, dimensions, playability, legibility, caption timing, product fidelity, sources and removal of private notes. Use the renderer's lint/check tools as well; a build passing is not visual verification.

Deliver the MP4, poster, final captions, editable composition, source/assumption notes and actual provider spend when available. If access, budget or rendering is unavailable, deliver the completed production package and state what is missing; do not call a storyboard an MP4 or silently substitute a free animation for the requested generated video. Never silently change provider or increase the approved budget.

For outreach, draft an optional one-line introduction if useful. Most email clients do not support a dependable embedded interactive video; use a poster linked to an authorized hosted playback page or attach a video when appropriate. No fake play button pointing to unrelated content. Hosting, sending messages, enrolling sequences, publishing and analytics installation require separate user scope/authorization. A request for a video is not a request to email prospects.

Measure attention and replies separately: a play is not a completed view, a completed view is not a positive reply, and a reply is not pipeline. Do not add a tracking pixel or identify viewers by default.


---
## Packaged resources

Full skill folder: https://greenfield.tools/downloads/cold-video.zip
Reference guides are included below. For scripts, templates and example inputs, download and extract the ZIP; preserve its folder structure. `<skill-dir>` means that extracted folder.


---
## Reference: engines.md

# Assemble generated footage into the final video

Runway or fal.ai supplies the paid generated footage. These tools handle the final sequence, exact product captures, titles, captions and sound; they do not replace the provider workflow.

Reviewed October 7, 2026. Provider details change; verify current official docs when invoking them.

## HyperFrames

Default when available for a new video. Load the installed entrypoint, route by deliverable and read core/CLI plus relevant animation/audio guidance. Build a native timed composition, not arbitrary HTML with a filename changed. HyperFrames owns clip and media playback; the animation runtime controls visual state. Use finite, seekable timelines and ship required assets. Run checks, render and inspect the result. https://hyperframes.heygen.com/ ; https://github.com/heygen-com/hyperframes/blob/main/packages/core/docs/core.md

## Remotion

Use when requested or an existing source project already uses it. Map shots to sequences with explicit frame ranges; derive transforms/opacity from frame state and preserve input props for buyer variants. Keep render-time data frozen and assets local. Read current rendering and licensing requirements. Validate the real video, not just the React preview. https://www.remotion.dev/docs/ai/skills ; https://www.remotion.dev/docs/use-current-frame

## Storylane

Borrow authentic product context, focused guided steps and clear hotspots. Use an existing authorized Storylane capture/export if supplied, respecting its actual capabilities. This skill does not have a Storylane connector and does not promise automatic HTML cloning. https://docs.storylane.io/recording-demos/recording-html-demos

## No renderer available

Complete script, storyboard, sources, shot list, poster and draft captions. State that rendering remains unavailable and identify the dependency. Ask only if installing, paid usage or external action needs authorization; otherwise proceed with an appropriate available renderer. Never claim that the preparation script renders a video.


---
## Reference: fal.md

# fal.ai generation workflow

Use the current official model page for the specific video endpoint; fal hosts multiple models with different schemas, prices, durations and rights. Do not treat fal as a single video model. This file is workflow guidance, not an installed or authenticated connector.

1. Inspect available authorized access. For API use, follow current SDK setup and keep `FAL_KEY` in the approved secret environment, never in a brief or generated HTML. Do not read or print credential values to prove they exist.
2. Check the selected model's schema, input assets, duration, dimensions, output format and current billing units. Fill the provider plan and obtain any missing spending authorization.
3. Submit the approved shot to the queue once. Persist its `request_id` immediately with the model/shot mapping.
4. Poll the same request using bounded waits and provider retry guidance. A timeout is not proof of failure. Retrieve results and inspect provider error fields even when the queue status is completed.
5. Review footage for continuity, anatomy, misleading product details and legibility before assembly. Record actual usage when exposed; otherwise label spend as estimated.
6. Preserve completed results. Do not switch endpoint, duplicate an uncertain submission, add variants or increase the spend ceiling without applicable authorization.

Official references checked October 7, 2026:
- Queue submission, status and result retrieval: https://fal.ai/docs/documentation/model-apis/inference/queue
- Pricing and model selection: https://fal.ai/pricing

Without provider access or budget approval, complete the prompts, shot list and storyboard and identify generation as pending. Never represent the planning package as a generated video.


---
## Reference: production.md

# Production brief and acceptance

Top-level JSON: `title`, `product`, `persona`, `scenarioLabel`, `evidence`, `shots`. Persona has `name`, `role`. Evidence objects have unique `id`, `claim`, `source`, `status` (`documented`, `user-confirmed`, `illustrative`).

Each shot: `id`, `seconds` (2–20), `headline`, `narration`, `visual`, `mediaType` (`product-capture`, `diagram`, `generated-scene`, `title`), `evidenceIds`. Optional `assetPath` points to a local licensed/reviewed image/video; `generationPrompt` describes an optional generated scene. Evidence must support the capability, not merely mention the product. No API credentials or private seller notes in the brief that will be shared.

The preparation helper checks the format, estimates narration pace and emits a render specification. Keep each shot's copy readable at its planned duration. It rejects a script exceeding 190 words per minute overall or per shot; slower is usually better. This is a rough drafting limit, not a voice timing measurement.

For `generated-scene`, `generationPrompt` is required. The helper emits a separate `provider-plan.json` with unresolved provider, model, access, price and budget fields. Null values are preparation placeholders, never permission to submit or spend. The plan contains only shots needing generation. Match each editorial shot duration to the selected provider's supported generation lengths; budget for generated duration, then trim in assembly. Local assets are copied into the production package; the helper does not upload them.

Recommended scene design:
- Recognizable human event: a message, queue item, case, order or account.
- One information change per shot; purposeful highlights and transitions.
- Keep case/person/customer identifiers consistent through all shots.
- Let real product UI carry feature claims; treat generated workplace shots as illustrative.
- On-screen words support the action, not a second competing narration.
- End on a relevant question that invites correction or interest.

For most prospect videos, start with 16:9 at 1920×1080, captions within safe margins and a clear poster. Recompose for vertical delivery rather than cropping essential product controls. Normalize speech and keep any music below it. Do not invent a voice clone or real-person endorsement.

Final acceptance: claims supported; prospect assumptions labeled; actual video opens; correct duration/size; no blank frames or accidental pauses; final frame holds; text readable on a small screen; captions synchronized; intelligible audio without clipping; muted comprehension; asset rights recorded; no credentials/private author notes. Keep measured results separate from hypotheses about sales effectiveness.


---
## Reference: providers.md

# Paid provider plan

Cold Video is a paid-generation workflow. The skill itself carries no credits or keys. Choose Runway or fal.ai based on user preference, existing access and the current model's ability to produce the required shots. Do not generate the same draft on both by default.

Before any paid submission, complete `provider-plan.json` from the preparation helper:
- Provider and specific model/endpoint, verified from current official documentation.
- Access route: supported connector, authenticated service UI or API with an environment-based credential.
- Exact prompts, approved reference assets, duration, aspect ratio and count per shot.
- Current unit price, units, currency, price-source URL/date, estimated first-pass cost.
- Maximum authorized spend and permitted number of regeneration attempts. Include audio/upscaling/assembly charges when relevant; do not assume every cost is included in the generation rate.
- A plain-language approval record referencing actual user authorization. A JSON boolean alone is never evidence of user consent.

Preparation is free of provider calls; the helper intentionally leaves pricing and authorization unresolved. Budget null means unapproved, not unlimited. If the provider does not expose a reliable price, report that limitation and obtain a bounded spending instruction before using it.

Keep job ID, shot ID, prompt version, request time, status, asset location and reported cost in a local generation log. Submit once and resume polling the same job after interruptions. Do not run automatic paid regeneration loops. Check actual cost before proceeding to the next batch. Existing approval remains valid within its scope.

Official references, checked October 7, 2026; recheck at execution:
- Runway setup: https://docs.dev.runwayml.com/guides/setup/
- Runway pricing: https://docs.dev.runwayml.com/guides/pricing/
- fal pricing: https://fal.ai/pricing
- fal queue lifecycle: https://fal.ai/docs/documentation/model-apis/inference/queue


---
## Reference: runway.md

# Runway generation workflow

Official entrypoint checked October 7, 2026: https://docs.dev.runwayml.com/guides/using-the-api/

This skill includes workflow guidance, not an installed or authenticated Runway connector. Discover an available supported connector/SDK and verify its current model, duration, input, output, pricing and task-status contracts before use. Do not hardcode a model from memory.

Before requesting a paid generation, prepare the exact shot prompt, reference image, shot count/duration, usage destination and estimated cost. Check existing user authorization; request only missing approval. Use a fictional generic persona rather than a real prospect's likeness. Do not upload private customer screenshots or records without authorized disclosure.

Generate human/workplace establishing scenes only where they materially improve the story. Keep product UI and text outside generated footage. Freeze an approved character reference if continuity matters. Never claim a shot's depicted outcome is a verified customer result.

Submit once, retain the returned task ID and poll that task to completion with bounded waits. If a request times out after submission and the outcome is unknown, recover its status before retrying; avoid duplicate paid jobs. Stop after a failure or exhausted approved budget and preserve completed outputs. Review generated assets before adding them to the final render. Use approved asset access/download methods and observe provider delivery restrictions.

No Runway access: finish the production package and state that generation is pending provider access. An alternative provider or capture-only video requires the user's direction when it changes the requested output or spending scope. Never put API keys in HTML, URLs, storyboards, logs or generated artifacts. API credits and web-app credits may be separate; check the actual access route rather than assuming a subscription covers API use.
