---
name: film-storyboard-board
description: Plan a short AI film before any video is paid for. Turns one line, and optional photos of the user's own product or place, into a 6-shot list in film order (establishing, detail, signature moment, people from behind or a second angle, light change, hero close), renders one cheap draft keyframe per shot with GPT Image 2, and lays them out on one 16:9 storyboard board (9:16 on request) with shot numbers, labels and camera notes drawn locally so every word is exact. A script then prices the planned shots on every main video route (Seedance 2.5 and 2.0, Kling 3, Veo 3.1 fast, Wan 2.2), with and without audio, from a dated price file. The shot list hands straight to the Cinematic brand film or Destination teaser Skill. For brands, agencies, hotels, creators and filmmakers.
metadata:
  type: image
  version: 1.0.0
  category: Video & animation
  tagline: Use this Skill to plan a 6-shot AI film from one line, with a shot list, a keyframe board and the price of every video route, before any video is paid for.
  made-for: Brands, Agencies, Creators, Hotels and resorts, Filmmakers
  generates-with: Shot list + 6 GPT Image 2 draft keyframes on one board PNG, 16:9 or 9:16, + a video price table from a dated price file
  requires: Node.js 18 or newer for the scripts; the sharp package for the board step (run `npm install sharp` in the Skill folder, Node.js 20.9 or newer); your own FAL_KEY only if you run scripts/fal-run.mjs
  outside-costs: About $0.34 for a 6-frame board on fal (GPT Image 2 at medium, about $0.04-0.07 a frame with its references), or about $0.52 with a low-quality rough pass first; the 6-shot sample cost $0.53 in 12 calls (a rough pass, then the clean board), with no re-rolls. About $0.06 a re-roll. No video is made, and the price table is free. Billed to your own fal account; quote the total and get a yes before the first paid call.
  updated: 2026-10-19
  title: Film storyboard board
  availability: live
  summary: Plan a 6-shot AI film from one line, with a shot list, a board of draft keyframes and what each video model would charge, before you pay for any video.
  command: /film-storyboard-board my coffee pouch, a harbour roastery from first roast to first cup, 30s 16:9
  output: PNG · 16:9 board of 6 keyframes (9:16 on request) + shot list, video prices and film handoff
  required-input: Brand, product or place + one-line idea; own photos optional
  creator: meleon
---

# Film storyboard board

Turn a brand, product or place and a one-line idea into a film plan you can approve before any video is paid for: six shots in the order an editor would cut them, one draft still per shot, all on one board with exact labels, and a table of what each video model would charge to film it. The board costs cents. The film costs dollars. When the user is happy, the same shot list goes straight into the Cinematic brand film or Destination teaser Skill.

## What you need

- The name (brand, product or place) and the idea in one line ("a small-batch coffee roastery by the harbour, one morning from first roast to first cup").
- Kind: place, product or brand. It decides the shot ideas and which film Skill the board hands to.
- Film shape: 16:9 (default) or 9:16 for Reels, TikTok and Shorts. Length: 30 s (6 shots, default) or 20 s (4 to 6 shots, a teaser). The board itself is 16:9; a 9:16 board on request.
- People: none (default) or fictional adults seen from behind, in silhouette or small in frame. Never real people, celebrities or public figures, never minors, and never made from a photo of a real person. The board does not take photos of people.
- Optional, strongly recommended for a real product or property: the user's own photos. One product photo (whole product, label readable) and up to 2 place photos (an exterior, an interior). Only the user's own photos or photos they have rights to, and no recognisable people in them (crop people out first). Ask, and stop if the answer is not a clear yes.
- If the place or product is real, agree that the board shows only what it really has and looks like.
- Logos are not drawn into frames: generated lettering comes out wrong. A product keeps its own label from its photo, and the board's title is set locally.
- **Limits: faces.** The board is the first step of a Seedance film, and Seedance on fal refuses start frames that show a clearly visible realistic face, even a fictional one. So frames keep faces turned away, in silhouette or small. If the user insists on a face, mark that shot `face_visible: true`: check-board warns, and the price table shows Kling 3 and Veo 3.1, which accepted a synthetic face in testing (`references/video-routes.md`).

## What you make

1. `board.json`: the shot list (locks, captions, keyframe and motion prompts, seconds per shot). Its shots use the same fields as the film Skills' shot lists.
2. `frames/`: one draft keyframe per shot, named after its request (`01-establishing-frame-medium-1.jpg`), 1280 × 720 (16:9) or 720 × 1280 (9:16), GPT Image 2 at medium quality (`-frame-low-` for a rough pass).
3. `board.png`: the storyboard board, 2560 × 1440 (or 1440 × 2560): the title and idea, every frame with its number, slot, seconds, caption and camera note, and a footer with the price of each main video route and the date those prices were checked. All text is drawn locally. Beside it, `board.png.json` (the layout record) and an optional WebP preview.
4. `prices.md`: the full price table. Every route, with and without audio, the seconds each one bills, the source page of each price, and the whole film on the Meleon film Skill.
5. `film.json` or `teaser.json`: the handoff file for the film Skill.

## How to run it

**Budget: about $0.34 for a 6-frame board at medium quality (about $0.04-0.07 a frame with its references). With an optional rough pass at low quality first, about $0.11 for the rough frames and about $0.40 for the clean board after them, about $0.52 in all. About $0.06 for each re-roll. No video is made. The price table, the board layout, the checks and the handoff are free.**

Before the first paid call, run `node scripts/build-requests.mjs --board board.json --stage estimate`, quote the board total it prints, and get one explicit yes on it. Then, at every paid step, tell the user the model, the number of calls and the cost, and ask again if the spend will go past the quoted total. To send a request, POST the printed JSON `input` to the fal model id in that request with the user's own FAL_KEY (`scripts/fal-run.mjs --request <file> --out frames --approved` does this and embeds local photos as data URIs; the Skill never stores keys), or paste the prompt and photos into any GPT-Image-class image editor. Frame requests carry `prompt`, `image_size` (1280 × 720 or 720 × 1280), `quality` ("low" or "medium"), `num_images` 1, `output_format` "jpeg", and `image_urls` when there are references.

1. **Brief (free).** Confirm the name, the line, kind, film shape, length, people, photos (and the rights question), whether the place or product is real, and the board shape. Choose the look from `references/shot-grammar.md` (teal-amber, warm-kodak, cool-fuji, blue-hour, natural).
2. **Shot list (free).** `node scripts/build-shot-list.mjs --out board.json --name "..." --idea "..." --kind place|product|brand --grade <grade> [--length 20] [--shots 4|5|6] [--aspect 9:16] [--board 9:16] [--people fictional] [--product-photo p.jpg] [--place-photos a.jpg,b.jpg] [--resolution 1080p]`. Fill every `FILL:` field: `locks.place`, `locks.product`, `locks.people` and `locks.wardrobe` (when used), and for each shot the `caption` (at most 60 characters, printed on the board), `keyframe_prompt` and `motion_prompt`, using `references/shot-grammar.md` and `references/prompt-patterns.md`. The motion prompts cost nothing now; the film Skill uses them later. Show the user the plan in plain words. For a free picture of the order, `compose-board.mjs --placeholders` draws the board with empty panels.
3. **Spend gate (free).** `node scripts/build-requests.mjs --board board.json --stage estimate`. It prints the board cost and the video price table. Quote the board total, say the video prices are for information only, and wait for one explicit yes.
4. **Establishing frame first (about $0.04-0.05).** `node scripts/build-requests.mjs --board board.json --stage keyframe --shot 1 --out requests --inline`, then `node scripts/fal-run.mjs --request requests/01-establishing-frame-medium.json --out frames --approved`. Look at it. When it is right, put its path in shot 1's `frame` and in `references.place` (unless the user's place photos are the reference), so every later frame shows the same place. After a rough pass, the clean shot 1 replaces the rough one there.
5. **Other frames (about $0.05-0.07 each).** `--stage keyframe --shot rest --out requests --inline`, send each one. Open every frame and check: the same place as shot 1 (and as the user's photos), the product exactly as its photo with the label letter for letter, faces hidden, no extra people, natural hands, no stray text or signs, and the tasteful-framing rules in `references/prompt-patterns.md`. Re-roll a frame by changing one thing in its prompt (at most 3 attempts per shot). Put each approved path in that shot's `frame`. Optional rough pass, when the user is unsure of the plan: run steps 4 and 5 with `--quality low` first (about $0.11 for six) and agree the order and framing. Then put each approved rough frame's path in that shot's `rough_frame` and run steps 4 and 5 again at medium: each clean frame carries its rough frame as one more reference and keeps the agreed composition (about $0.01 more a frame). Leave `rough_frame` empty for a shot whose rough frame has a fault, and fix its prompt instead.
6. **Board (free).** Run `npm install sharp` in the Skill folder once, then `node scripts/compose-board.mjs --board board.json --out board.png --preview board-preview.webp`. Add `--guides` for 9:16 frames (it marks the top 12% and bottom 20% that apps cover). Fonts: Helvetica by default (DejaVu on Linux); pass `--font-file brand.ttf --font "Family Name"` for brand type. See `references/board-layout.md`.
7. **Price table (free).** `node scripts/price-table.mjs --board board.json --out prices.md` (`--all` lists every resolution; `--resolution 1080p` prices a 1080p film). Tell the user, in plain words, the cheapest silent route, the cheapest with sound, and the whole film on the Meleon film Skill. If the price file is more than 30 days old the script warns: re-read the fal pages and update `assets/video-prices.json` first.
8. **Check (free).** `node scripts/check-board.mjs --board board.json --file board.png --prices-md prices.md [--preview board-preview.webp]`, then open the board at full size and go through `references/output-spec.md`, reading every label letter by letter. Fix and recompose until it passes.
9. **Hand off (free).** `node scripts/handoff.mjs --board board.json --to cinematic-brand-film --out film.json` for a product, a brand or any 30 s board; `--to destination-teaser --out teaser.json` for a place with a 20 s board. It prints what changes. Do not start the film here: the film Skill quotes its own total and asks before spending (see "Handing the board to a film" below).
10. **Deliver.** The board, its preview, the frames, board.json, prices.md and the handoff file. Say which frames were re-rolled and anything still imperfect, and repeat that no video was made.
11. **Clean up photos.** Delete the user's photos from the working folders unless they want them kept, and any public copy. fal keeps request inputs (including inline photos) and outputs on its side for a period: tell the user they can delete them from their fal dashboard or ask fal to, and to check fal's current retention policy.

## Handing the board to a film

The shots in `board.json` already have the fields the film Skills read (`n`, `id`, `role`, `framing`, `person_in_shot`, `face_visible`, `keyframe_prompt`, `motion_prompt`, `duration`, `transition_in`, `keyframe`, `clip`, `in`, `out`). `scripts/handoff.mjs` writes the wrapper each Skill expects:

- **Cinematic brand film** (`film.json`): `locks.place` becomes `locks.location`, `locks.people` becomes `locks.cast`, `use_place_ref` becomes `use_location_ref`, a title card and an end card with the name are added, and the product photo is carried over. With people, run its `--stage bible` first. It has no blue-hour grade: pass `--grade` (the keyframes keep the board's look line).
- **Destination teaser** (`teaser.json`): for places, 20 s boards and 4 to 6 shots only. People and wardrobe become one `locks.people` sentence; `--season-mood` sets its brief line.
- In both, every `{{TOKEN}}` is written out in full, paths are made relative to the new file, and each shot keeps its `board_frame` to compare with. `keyframe` stays empty, so the film Skill renders each keyframe at high quality from the same prompt; `--use-board-frames` fills it with the board frames for a cheap 480p draft test only.

Then, in the film Skill: `node scripts/build-requests.mjs --film film.json --stage estimate` (or `--teaser teaser.json`). Its total matches the "whole film" line on the board.

## Files

- `references/shot-grammar.md`: the six slots and the 4 and 5 shot versions, cutting rules, slots by subject (places, products, brands), choosing the look, real places, vertical films, lengths.
- `references/prompt-patterns.md`: locks and tokens, captions, keyframe and motion prompt anatomy with examples, people and the Seedance face rule, tasteful framing, products and labels, low versus medium, failure modes and the fail path.
- `references/board-layout.md`: board sizes, how the grid is chosen, what each panel shows, text limits, fonts, guides, plan boards and the preview.
- `references/video-routes.md`: how the price table is worked out, each route (fields, lengths, audio, faces, best use), choosing a route, keeping prices current, and the handoff in detail.
- `references/output-spec.md`: deliverables, sizes, costs, the pass/fail checklist and what to do when a check fails.
- `assets/prompt-template.md`: the frame and motion prompts with placeholders.
- `assets/generation-input.json`: model ids, frame and board sizes, quality levels and approximate costs.
- `assets/video-prices.json`: the dated price file for every video route, with the source page of each price.
- `assets/board-example.json`: the filled shot list behind the preview (OSTRA, an invented harbour coffee roastery), every prompt as used, with its rough and clean frame paths.
- `assets/example-input.jpg`: the synthetic product photo the example used (whole pouch, label readable).
- `scripts/build-shot-list.mjs`: writes board.json with the slots and FILL fields.
- `scripts/build-requests.mjs`: the board estimate (with the video price table) and the frame requests for any shot. Calls no API.
- `scripts/fal-run.mjs`: sends one request with the user's FAL_KEY after `--approved`, waits, downloads (never overwrites without `--force`).
- `scripts/compose-board.mjs`: lays out the board and draws every word locally (needs sharp).
- `scripts/price-table.mjs`: the video price table from the price file, as text, Markdown or JSON.
- `scripts/check-board.mjs`: technical checks on board.json, the frames, the board, the prices and the handoff file.
- `scripts/handoff.mjs`: writes film.json or teaser.json for the film Skills.