mcpField
I
it-reelsmaker

it-reelsmaker

github.com/itpartypattaya创意与媒体9127 次安装2 天前更新
代码仓库

关于 it-reelsmaker

面向 Claude Code 的短视频剪辑技能,依据项目中的品牌资料和视频简报组织剪辑流程,并通过脚本处理重复步骤。它涵盖环境检查、品牌设置、素材与风格选择,以及从粗剪到成片的制作环节。

主要功能

  1. 01检查视频制作环境与依赖
  2. 02管理品牌资料和设计规则
  3. 03通过项目设置控制剪辑选项
  4. 04使用脚本处理重复剪辑步骤
  5. 05涵盖粗剪、字幕、封面与母版输出

适用场景

  1. 01按品牌规范制作竖屏短视频
  2. 02将长录制素材整理成多条片段
  3. 03为视频项目保存品牌规则与剪辑偏好

安装

复制下面的命令,在终端中运行。

$npx skills add https://github.com/itpartypattaya/reels-montage --skill it-reelsmaker

安装后在 Claude Code 中输入/it-reelsmaker确认已加载。

包含的文件

除 SKILL.md 外,安装时一起下载的参考资料和脚本。

assets/
reel-defaults.json
assets/brand-template/
brand.json
README.md
rules.md
assets/brand-template/assets/
README.md
assets/remotion-kit/gen/
mascots.ts
registry.ts
assets/remotion-kit/kit/
anchor.ts
brand.ts
Callout.tsx
defaultBrand.ts
Inserts.tsx
LightFlash.tsx
Phrase.tsx
Presenter.tsx
Sample.tsx
assets/remotion-kit/kit/mascot/
AtlasMascot.tsx
frame.ts
MascotLayer.tsx
rig.ts
types.ts
assets/remotion-kit/kit/scenes/
Chat.tsx
Contrast.tsx
Cover.tsx
CtaAction.tsx
Hook.tsx
index.ts
List.tsx
parts.tsx
Quote.tsx

README 原文English

来自项目 README

README 暂无中文译文,以下为英文原文;中文介绍见上方。

Editing vertical videos — IT Reelsmaker

How to use. A Claude Code plugin: a depersonalized version of a working skill built on real videos, with its techniques, styles and verified numbers kept. You don't need to edit SKILL.md: your own choices go into the plugin settings, the project defaults (reel-defaults.json) and the brand folder. The ⟨YOURS: …⟩ marks below are places taken from the brand profile (brand.json, rules.md) or decided in the brief.

Brands live in the project folder: {{PROJECT_ROOT}}/brands/<slug>/ holds the brand.json profile, the rules.md design rules, the assets/ files (logos, LUTs, fonts) and, if the brand has them, its video guide guide.md, CTA library cta.md and other documents. Template: ${CLAUDE_SKILL_DIR}/assets/brand-template/. Before editing, the agent asks which brand the video is for. {{NAME}} placeholders are fields of the selected brand's profile (table: references/brands.md).

Long sections live in references/ (table at the end). Scripts for every repeatable step (rough cut, speech mask, faces, visual plan, inserts, brands, cover, mastering) are in ${CLAUDE_SKILL_DIR}/scripts/: run them from {{PROJECT_ROOT}}, don't rewrite them for a video; what differs between videos goes into the video's JSON files. Which script for which step: references/scripts.md.

Language. Talk to the person in their language and translate any fixed labels from this file (style and tone names, question options, plan and report headings). On-screen text (hook, cards, scenes, CTA, subtitles) is in the language of the video, not of these instructions.


0. Environment, settings, brands

Environment, once per plugin version. it-reelsmaker.json → doctor_ok.version equal to the installed version (${CLAUDE_SKILL_DIR}/../../.claude-plugin/plugin.json) → skip this check; run it again after an update or when a script fails for a missing tool. The skill works where the agent runs commands and sees files on your computer, that is, in Claude Code. Run python "${CLAUDE_SKILL_DIR}/scripts/doctor.py" from the project folder (or python3, py -3): it checks ffmpeg, Python, Pillow, Node.js, the Remotion project, the transcriber, the face model and rembg, and prints the install command for this OS for anything missing; exit code 1 means a required program is missing, and a success on everything required and recommended is remembered in doctor_ok. No Remotion project yet → kit.py new <folder> creates one with the kit wired in (then npm install in that folder); an existing project: doctor.py compares its kit with the plugin's, kit.py update if it is missing or older. No tool for commands and files (claude.ai chat, Cowork without computer access) → say it plainly: “Editing runs in Claude Code on your computer: it needs ffmpeg, Node.js with Remotion and Python 3”, and do not pretend to edit. One program missing → name what to install and what won't work without it (without Remotion: graphics and rendering; without Python 3.9+: every script, from the rough cut to mastering). Pillow (pip install Pillow) is needed for contact sheets, covers and logos; OpenCV only for face measurement.

Project settings come from the plugin settings (Claude Code asks for them when the plugin is enabled; change them with /config):

PROJECT_ROOT  = ${user_config.project_root}
REMOTION_DIR  = ${user_config.remotion_dir}
ASSETS_DIR    = ${user_config.assets_dir}      empty = no library of your own (section 11)
FACE_MODEL    = ${user_config.face_model}      empty = faces checked frame by frame (references/faces.md)

A value that is empty or still reads ${user_config.…} (the skill was not installed as a plugin, or the setting is not set) → take it from it-reelsmaker.json in the project folder (the current folder or its parent); if that is missing too, ask once (project folder, Remotion project) and write it there. The other way round, a plugin setting that is set (expanded, not empty) while it-reelsmaker.json lacks it or holds another value → write it into it-reelsmaker.json under the same name (project_root, remotion_dir, assets_dir, face_model), keeping the other fields: the scripts read only that file, never the plugin settings. Further in the text: {{PROJECT_ROOT}}, {{REMOTION_DIR}}, {{ASSETS_DIR}}, {{FACE_MODEL}}.

What's new after an update. Once the project folder is known and before the editing questions, read version from ${CLAUDE_SKILL_DIR}/../../.claude-plugin/plugin.json and last_seen_version from {{PROJECT_ROOT}}/it-reelsmaker.json (create the file if needed and keep its other fields). Compare versions as numbers, part by part (1.10.0 is newer than 1.9.0). The installed version is newer → show one short block “What's new in X.Y”: at most 4 points from the ${CLAUDE_SKILL_DIR}/../../CHANGELOG.md entries newer than the last seen version and not newer than the installed one, in the person's language and without technical detail (across several versions: the headline, the first point, of each, newest first; fixes and housekeeping only when nothing else is new); then write the installed version there. No last_seen_version: if the project already has edit/ or brands/, it was used with 1.0.0, which kept no record, so take 1.0.0 as the last seen; an empty project (a first run) → instead one short block “What I can do”, three lines in the person's language: a raw talking-head take into a finished video; a long recording into a series of clips; no speaker on camera needed: scenes over a voice note recorded on a phone, optionally with a brand mascot, or that voice over your own silent shots (or a promo with no voice); then write the version. Something can't be read (no plugin.json at that path, as in a manual copy of the skill, no version, no CHANGELOG entry) → skip this step and write nothing. Never update the plugin yourself: how to update is in the README.

Brands: {{PROJECT_ROOT}}/brands/<slug>/ (brand.json + rules.md + assets/), as many as you like, managed with brand.py (list, new, show, tone, rule, use, stage):

  • minimum: a name, 1–3 colors and the brand tone, one of eight presets from premium to bold (references/brands.md, with how to offer eight in a 4-option question). The tone sets the limits for the brand's videos right away: which memes are allowed, how many cutaways, how loud the techniques can be (light flash, whip, shake, full-frame scenes) and the scene tones; louder only on explicit request for a video (tone_override). “Change the brand tone” rewrites it in the profile at any time. The agent works out color roles, text contrast, fonts that cover your language's script and the logo search itself;
  • older files: a brand.json or it-reelsmaker.json with an older schema is brought up to date once, with a .bak copy and one line saying what changed (references/migrations.md);
  • brand documents: rules.md (rules in words, bans, voice), guide.md (the brand's video guide: palette roles, typography, signature elements, motion, imagery bans; brand.json → guide), cta.md (the brand's CTA library with exact texts; brand.json → cta_library), other .md documents linked from rules.md; brand.py show <slug> lists what it finds;
  • revisions (yours or the client's) and anything the person says about the brand as a whole go into the brand folder, not into one video's notes: a rule or ban → rules.md with a date (brand.py rule), a CTA → cta.md, a visual decision → guide.md (references/brands.md); the brand's next video already knows them;
  • profiles live in your project, not in the plugin, so a plugin update does not touch them. Moving from an old version: if ~/.claude/skills/reels-montage/brands/<slug>/ exists (versions before 1.0 were installed by cloning), offer to move those folders to {{PROJECT_ROOT}}/brands/.

Craft rules and how far to trust them (references/playbook.md): measurement (scripts, thresholds) is kept apart from taste (hook, pace, shots, text). The person's own rules live in the brand's rules.md (owner decisions, dated) and in the optional project playbook {{PROJECT_ROOT}}/playbook.md (cards with an ID, scope, reason, source and trust: owner ⭐ · verified on edited videos 🟢 · external advice ⚪); read both before the plan. Rules disagree → scope first, then owner → verified → external, else ask. A guide or someone's video to learn from goes into {{PROJECT_ROOT}}/refs/ and is reconciled rule by rule, conflicts shown to the person; a correction that repeats, or comes with “always”, becomes a rule.

Video settings (reelcfg.py show / save): edit/<id>/reel.json holds the brand, style, inserts (use_broll, use_code_scenes = code scenes, use_scenes = designed scenes, use_memes, use_local_memes, …), intensity (minimal / moderate by default / active) and meme size. Everything about inserts: references/inserts.md. Online sources belong to the online-sources add-on it-reelsmaker-online: without it the related settings are ignored. The skill does not offer the add-on on its own: it is named only in doctor.py's status row and as an option for a cut-out too heavy for this computer (section 15, matte.py, references/figure.md), and otherwise only when the person asks about online sources.

Your own settings live in your project, never in the plugin folder (an update replaces it). Project defaults: {{PROJECT_ROOT}}/reel-defaults.json, the format of the plugin's assets/reel-defaults.json with only the settings you change (default brand settings.brand, inserts on/off, intensity, library_dirs, your labels for intensity and brand tones…), edited with reelcfg.py defaults [--set field=value …] [--unset field …]; which layer wins is listed once, in references/brands.md (“Layers”), and reelcfg.py show prints where each value comes from; the brand tone's ceilings still apply. Project-wide notes (folder layout, which Python to run, servers, lessons from past videos, the person's ready prompts) go into the project's CLAUDE.md, which Claude Code reads by itself.


1. The main rule: the template is a menu, not a checklist

Everything described below (logo, end card, hook headline, cards, focus brackets, role tags, verdict scale, “save” bookmark, music, B-roll, code scenes, designed scenes, memes, a brand mascot, special techniques) is a set of possible techniques, not a required package. A video has only a clean edit with shot-size changes, plus subtitles, unless something else was chosen in step 0 (inserts) or the brief (step 7), or stated directly in the prompt. Inserts are off in the skill defaults, and no brand tone or profile turns them on; step 0 saves the person's answer whole. Carrying everything over makes a video noisy and templated.

Only the quality rules always apply:

  • no text on a face; nothing important in the UI zones (grid below);
  • graphics and highlights start on their word (±2 frames); timing comes from the transcript, not by eye;
  • one typography style and one accent color per video;
  • no leftover takes or slips in the final video;
  • brand voice {{VOICE}}, with no {{FORBIDDEN_WORDS}} and no {{FORBIDDEN_IMAGES}}, in graphics, B-roll, code scenes and memes alike;
  • an insert (B-roll, meme, designed scene) only with an answer to “why”, within the intensity budget and within the brand tone; film stills, celebrities and memes without rights are never burned in;
  • facts in graphics only from a source: a quote verbatim from the speech, a number from the speaker, the brief or the client;
  • nothing is replaced quietly: when a program, model or font is missing or a step fails, say what is missing and what it changes in the video before going on the simpler way (references/pitfalls.md);
  • any download and any paid action only after the person's approval (“yes”) of a visual plan with source, size and price;
  • publishing only after a “yes” from {{APPROVER}}.

2. Frame grid 1080×1920

ZoneWhat
y 0–220social app UI, nothing important
y 1500–1920caption, buttons, username, nothing important
x 960–1080likes and comments; text stays out
face (measured)no-go zone for any text, 60 px margin
y ≈1250–1390subtitles: top = measured chin + 30 px; at the edge away from the speaker or bottom left; centered only if it doesn't fit otherwise

The UI rows are the defaults; a project with a taller app UI (TikTok's bottom, say) sets its own in reel-defaults.json → meme_layout.safe (top, bottom, right, left, px from the edge), and every layout and check uses it.

Where the head is comes from the face-detection model's measurement, not by eye (references/faces.md; false “faces” on knees and hands are not a frame error and are dropped by the filter): faces across the whole rough cut every 0.25 s → for each span, the room in the “headroom” zone (from y 250 to face top − 60) for the hook and cards, in the “chest” zone (from chin + 60 down to the subtitles) and at the sides, plus the subtitle height. The chin stays above the subtitles in every camera shot: zoom is calculated by formula (screen = (x − cx)·z + 540). No model → check frame by frame.

3. Styles — one per video

Choosing the style is the first question, before any editing (step 0): the subtitle position, the room in the “headroom” zone and the camera shots depend on it. A previous choice is not inherited, except through a series preset (step 0). Colors from different styles are not mixed. The kit draws “Marker” (and v2) and “Brand”; the others are custom: a per-video composition, more time and a check of its animations, so step 0 offers the kit's styles, and a custom one when asked for or when it is the brand's default.

StyleLookGood for
“Marker”{{FONT_TEXT}}, dark {{INK}} text on a {{MARKER}} marker bar, light thesis cards, no outlines or shadowsmonologues, intro videos, skits. A good default
“Brand”{{DARK}} + {{ACCENT}}, {{FONT_HEADING}} + {{FONT_TEXT}}, focus brackets ⌜⌝⌞⌟ (the kit draws them inside stat, word and cta scenes; on a word over the video, a per-video component), accent marker barjob openings, case studies, anything where recognizability matters
“Minimal”bold white capitals bottom left in 2–3 lines, one accent word in color ⟨YOURS: example olive #B3BC6E⟩business insight, “confident and clean”. Custom
“Editorial”serif {{FONT_SERIF}} + sans-serif, beige accent ⟨YOURS: example #E6C999⟩; the kit sets its headings in fonts.serif (or looks.editorial.heading), the cards and scenes themselves in a per-video compositiontestimonials, stories, magazine tone. Custom
“Bold”white black-weight capitals, main word in black on a lime marker bar ⟨YOURS: example #D4E79E⟩, the bar fills from left to right over 6–8 framesprovocative hook, controversial claim. Custom
“Glass”glass cards {{DARK}} 35–45%, blur 12–16 px, glowing dividersskits only; breaks the “no glow” rule, so only by explicit choice. Custom

Fonts: check that the font covers your language's script (for example Cyrillic or Vietnamese diacritics) in the font file itself. Verified Cyrillic check: Satoshi and General Sans have no Cyrillic; Manrope, Inter, Inter Tight, Onest, Playfair Display and Cormorant Garamond do. The paid Canela and Neue Montreal have not been checked. Load fonts via @remotion/google-fonts with subsets for the scripts you need, for example subsets: ["latin"] or subsets: ["cyrillic","latin"].

Typography principle: “the person is the main subject, text is support”
  • 3–6 words on screen at most; large; lots of breathing room; readable within the first second; no more than 2–3 short lines at once;
  • no outlines, glow or shadows (a dated 2021–2022 look). Unreadable on a light background → a soft gradient darkening of the lower third, not an outline; its strength is measured, not guessed: visual_plan.py shade edit/<id> gives the value for 4.5:1 on the lightest frame (reel.json → subtitles_shade, kit default 0.35). The kit draws this darkening only under “Typewriter” subtitles; in “Accent” mode on a light background use “Bar” (plate) subtitles or a backing; for text in another zone (a style's white text in the headroom) shade … --scene <id> or --zone x,y,w,h;
  • text at the side or bottom, aligned to an edge, not centered; text never covers hands holding an object, a screen or the product;
  • an important word gets the accent color or a ×1.3–1.6 size, not both;
  • hook: no more than 6 words, one accent word;
  • a phrase is one block: parts of one thought (lead-in and big word, heading and caption) sit tight together, 15–25 px between visible edges, on a shared axis, in one zone of the frame, moving together; short function words (prepositions, articles, negations) and numbers do not dangle at the end of a line. Details: references/typography.md.
Subtitle modes

By default, subtitles cover all speech: videos are often watched without sound. “Selective” (the main phrase only) on request.

  • “Bar”: a 3–6 word phrase (≤ ~26 characters per line) on a {{MARKER}} marker bar; words are added as they are spoken. A punchline that must not read in two beats goes into cut.json → keep: it stays on one block in every mode, two lines if needed.
  • “Accent”: 2–3 words, {{FONT_TEXT}} 800, 64–72 px, the word being spoken in the style's accent color. Loud, for quick insights.
  • “Typewriter”: the whole phrase in 1–2 lines, 56 px (the kit); upcoming words at 30% opacity, spoken words appear as they are said, a caret (a thin bar in the accent color); color per speaker. Quieter and more premium, for skits and calm videos. Split by phrases and pauses (up to ~52 characters as a whole), not by a character limit.

Hide subtitles when on-screen text replaces them: a hook with a headline, a list card, a full-screen phrase, the end card. A card at the bottom of the frame: raise the subtitles above it or hide them for its duration.

Subtitles in another language (on request or chosen in the brief): subs.py phrases edit/<id> --lang <code> lists the speech by phrases; you translate each phrase in subs/<code>.json yourself (one phrase of translation per phrase of speech; the brand's voice and forbidden words apply; names, numbers and terms as said; as short as the speech), then subs.py apply checks it (reading speed: about 17 characters per second, never harder to read than the original subtitle) and writes captions-<code>.json, and reel.json → "subtitles_lang" puts it into the render. The font must cover that language's script; in a script written without spaces (Chinese, Japanese, Thai…) mark the word boundaries with |. Scenes still land on the spoken words. Scene texts in a translated version: write the hook, quote, slogan and CTA texts in the subtitle language too (a quote from the speech is then checked word for word against the translated subtitles), or keep them in the speech language and say why in the plan; a translated phrase that a scene covers for most of its time is hidden whole, not shown as a tail. subs.py srt [--lang <code>] gives a .srt file for platforms that take one (2 lines of 42 characters at most; a longer phrase becomes several subtitles). A re-cut keeps the translations of unchanged phrases; the stage refuses a translation of an older cut.

On top of subtitles, if the brief asks for them: “accent titles”, 2–4 main words per video shown larger, on a separate layer, on their word; the kit cannot take one word out of a subtitle line, so hide the subtitles for the title's moment (hide_subtitles on its card or scene), or the word appears twice. At most one word per video in color (usually the CTA).

4. Brand in motion

Brand elements that animate well ⟨YOURS: replace with your own⟩:

  • focus brackets ⌜⌝⌞⌟ close in on a main word or number over 0.4–0.5 s, like a viewfinder (the kit has them inside stat, word and cta scenes; brackets on a spoken word over the video are a per-video component, references/brands.md, “In Remotion”);
  • marker bar: a 6–8 px vertical bar to the left of the card that grows with the text;
  • a grid of cards from which one stands out (for “from 200 → 5”);
  • all-caps labels with 0.2 em letter spacing above the card heading: CASE STUDY, INSIGHT, ⟨YOURS⟩.

Motion (one reading of “calm, precise, premium”; ⟨YOURS: change it if the brand is energetic⟩):

  • entrance: smooth deceleration (Easing.out(Easing.cubic) or spring with damping ≥ 200), 12–16 frames;
  • exit is faster: 8–10 frames, opacity plus a 20–40 px shift;
  • no bounces, shakes, spins, glitch, neon or gradients;
  • no more than one animated element on screen at a time, not counting subtitles.
  • a brand mascot's blink, breath and mouth are background motion and don't count; its gestures do: at most one per 0.8 s, none within 0.3 s of a scene's entrance or exit (references/mascot.md).

Where video departs from the static brand guidelines: hook 92–120 px (≥ 76 inside the “framed” window), cards 54–64 px, subtitles at the kit's sizes, 56–66 px (otherwise unreadable on a phone; the numbers live in references/typography.md); a shot change every 1.5–3.5 s is normal even for a “calm” brand; a live speaker on screen, not stock footage.

5. Video profiles and formats ⟨YOURS: keep the ones you need, add your own⟩

The profile is what the video is for and how loud it may be; it sets the video's defaults under the brand tone, turns on its rules and brings its checklist (references/profiles.md): educational · entertaining · expert-clip · promo · ad (a paid ad: the ad safe zone, the brand by 3 s, claims with a source). A profile is opt-in: a video has none unless the person asks for one or for its rules, or the video is a paid ad (then ad, always: the platforms' rules). The format is what the video is made of, its usual length and graphics; without a profile it only guides the plan and is not saved, since a saved reel.json → content_format brings the profile of its row:

Format (content_format)EssenceTypical graphics (optional)ProfileLength
Insight (insight), list (list)one expert thought; steps or pointshook, 2–3 thesis cards, ending; numbered listeducational30–60 s
Case study (case)problem → how it was solved → resultbig number in brackets, a “funnel” of cardspromo30–45 s
Job opening / offer (offer)an open position or a productcard: role, city, terms, 2–3 points, CTApromo15–30 s
Testimonial (testimonial)a client quotequotation marks, name and role in capspromo15–25 s
Intro video (intro)who I am → what I do → how I'm different → CTA“NAME · ROLE” label, question hook, chips on their wordspromo25–35 s
Review (review), event (event)a place or product shown, often voice-over; an announcementnumber cards, the date and placepromo20–45 / 15–30 s
Skit / “Verdict” (skit), story (story)two-person dialogue, expert conclusion; a told storyrole tags, “Reject / Consider / Offer” scale ⟨YOURS: your own scale⟩entertaining45–70 / 30–60 s
Interview / Zoom (interview)a segment of a horizontal recording“framed” format (section 10)expert-clip30–60 s

End card (if chosen): {{DARK}} or light background, logo, {{TAGLINE}}, CTA. 2.6 s (the kit). A separate option is a logo sting without a CTA (2.6 s), when the call to action is spoken.

Hooks in the brand voice ⟨YOURS: your own examples⟩. Specifics instead of promises: “12 days from brief to result. Here's what sped it up”, “Why a résumé tells you almost nothing about sales”. Not suitable: loud promises, “Stop losing money”. For skits the hook is the mechanics, with no headline: the video opens with the most controversial line.

6. Pipeline

Three tools in sequence: transcription and cut plan (locally faster-whisper, or your own transcription tool) → the cut script cut.py (segments, color, speed-up, subtitles on the finished video's timeline) → Remotion (camera, graphics, subtitles, render) → audio mastering.

File layout per video: {{PROJECT_ROOT}}/edit/<id>/ with cut.json, reel.json, project.md (work log · strategy · brief · decisions · open items), transcripts/, final.mp4, captions.json; in Remotion, public/<id>/video.mp4, plus src/Reel<id>.tsx only when the video needs its own composition (the kit's ReelKit with props covers the rest). <id> is the source file number; a promo without footage gets a short name (promo-<brand>) and skips steps 1–6 (references/scenes.md, the “scenes only” format). The next video of a series starts from the series preset (step 0), not from a copy of the last folder.

A long recording → a series of clips (a podcast, webinar or interview of 10–90 min): longform.py and references/longform.md. One brief for the series; the whole recording transcribed once (transcribe.py, in the background) or the subtitles the person has (longform.py import); the agent reads it part by part (outline) and writes one card per clip by its first and last words, with no quota and no virality score; check finds and checks the pieces; the person approves the list (sheet, one stop); extract turns each approved card into an ordinary folder edit/<series>-<id>/ with its pieces as files and their transcripts, finished from step 5 on, each clip in a fresh context, one render at a time; its framed camera is proposed by longform.py camera after faces.py scan (who sits where asked once per series; review the shots, --write).

A voice-over or a mixed video (a voice note recorded on the phone over silent wide shots, clips or photos; a talking head with a stretch of voice-over; a text ending after the voice): the same folder and cut.json, the sound cut by ranges as usual and the picture in picture blocks, built by one cut.py run; color per place, strangers marked and hidden (a blocking check), the speaker's rules held only over the speaker; a photo's subject (roi) for its move, no slideshow: references/no-speaker.md. Before picking the shots, picture.py scan <clips> lists hints (shake, a restless picture, an app's tail, dark, talking, a turn to the camera, strangers?): each unchecked, look and decide.

A no-speech reel (no voice at all: silent shots or a person who does not speak, the brief's text on screen, sounds and music): reel.json -> voice: none; the brief's text word for word in edit/<id>/script.json, timed by its reading (visual_plan.py script), the clips in picture blocks on those blocks, visual_plan.py init --no-speech; the sounds and the music are always asked about (music composed in code by music.py, an own track, or one picked in the app): references/no-speaker.md, references/music.md.

Workflow (reel.json → workflow, reelcfg.py save edit/<id> --set workflow=…, the project default standard) sets how often the person is asked before the master. Asked for “quickly”, “as usual”, or a series → quick; a new brand, an ad or a first video for a client → standard or full.

workflowAsksStops before the master
quicknothing in step 0 when the brand is known (its style and subtitles, or the series preset; inserts off); the order of the lines as recorded (a found teaser or slow start → one line in the plan); the ending from the preset, otherwise asked in the cut plan's question (step 7: the CTA is never picked by the agent); the agent checks the board and picks the cover itself2: the cut plan, the preview with the cover
standardstep 0 (≤ 4 questions); the cut plan together with the structure and the brief in one question (steps 3a, 5, 7); the visual plan only with inserts3–5: step 0, the cut plan, the visual plan, the board, the preview
fullas standard, plus the profile question (“no profile” first), the Supports and, with a profile, its checklist in the plan and the report4–6
Step 0. Brand, style, subtitles, inserts — the first AskUserQuestion
  • A series (“the next one like last week”): reelcfg.py preset use <name> edit/<id> writes the series' answers, then ask only what the preset lacks. A preset is made from a finished video, reelcfg.py preset save <name> --from edit/<id>: its settings and its ending (corner logo, end card or sting with the card's lines), which visual_plan.py stage draws until the video's own stage changes it; the hook and measured values stay per video.
  • Profile and format (section 5; opt-in). A paid ad (an ad, a promoted post with a budget) → reelcfg.py save edit/<id> --set profile=ad, no question. The person asks for a profile or its rules (“as a promo”, “with the checklist”) → save it, --set profile=… content_format=…. Otherwise no profile in any workflow: name the format in the plan as a guide for length and graphics, and don't save it. In full, one separate question in step 0: “no profile” first, then the 2–3 likely profiles (references/profiles.md, “Choosing it”). The profile's defaults (intensity, scene tone, memes) stay under the brand tone: reelcfg.py show says what it held back; a brand's own tone for a profile is the owner's once-saved decision (brand.py tone <slug> <preset> --profile <id>), not a per-video tone_override.
  • No footage (“a video without filming”, “I don't want to be on camera”, a promo, an audio file only): one question, “scenes + your voice: record it on a phone (m4a, wav, mp3), an explainer of up to ~70 s” · “your voice over your own silent shots or photos (references/no-speaker.md)” · “scenes only: a promo of 15–25 s with music or sounds”; an audio file brought along with no footage is the first one, with silent shots the second (references/scenes.md). Silent shots and a text but no voice at all: the no-speech reel, with its sound question (sounds on events + music composed in code, an own track, or one picked in the app; references/no-speaker.md). With the online-sources add-on it-reelsmaker-online linked, its own narration option joins this question, following the add-on's rules.
  • Brand. If it is clear from the prompt, the folder or the project defaults (settings.brand), take its profile; otherwise offer the 3 most recent saved brands, and a new one via “Other” (name and colors). Read the brand's rules.md and its video guide guide.md (if set) before any graphics.
  • Style. The kit's styles with the recommendation for this video first and a one-line explanation; a custom one only when asked for or the brand's default (section 3).
  • Subtitle mode.
  • Inserts (multiSelect, if the prompt says nothing): B-roll from project materials and the library · code scenes in Remotion (diagram, interface, symbolic object; free) · designed scenes (hook, quote, number, list, CTA; references/scenes.md) · memes from your own folder and the library (if the brand tone allows them; friendly and bold recommend this option, but it is still the person's choice) · a brand mascot drawn in code, its mouth animated to the recorded narration (offered when the brand has one, brand.json → mascot, or the person asks; a brand without one, in a video with no speaker on screen (scenes over a voice, a voice-over over your shots, a promo) and a tone other than premium, sees it as one item marked new: “a brand mascot: drawn in your colors, or your own character picture brought to life”; references/mascot.md). With the online-sources add-on it-reelsmaker-online installed, online sources are added as well (with a price where they cost money). Inserts are off in the skill defaults, but your project defaults or the brand profile may turn some on: save the answer whole, the chosen ones true and the others false (reelcfg.py save edit/<id> --set use_broll=true use_scenes=false use_memes=false), then check with reelcfg.py show. Code scenes without B-roll footage: use_broll=true, use_project_footage=false, use_local_footage=false, use_code_scenes=true (code scenes are B-roll inserts; references/inserts.md). Intensity and scene tone follow the brand tone unless stated otherwise.

Limit: 4 questions; if the brand is clear, don't ask about it; quick: no question when the brand is known. Horizontal source → offer the “framed” format right away. Answers go into edit/<id>/reel.json and project.md.

Step 1. Analyze the source

ffprobe: resolution, fps, duration, rotation tag (for a phone MOV, the size stored in the file differs from the size after decoding). Larger than ~300 MB or 4K → make a working copy, but keep the zoom margin in mind (step 4). Before the plan:

  • whether the source was already sped up by its author in an editor: a rate above ~9 syllables/s (measured on Russian speech) means it is already sped up; set your own speed-up to ×1.0. It needs the words, so estimate it right after step 2: syllables per second = the vowels of the transcript's words ÷ the speech time (pauses don't count); transcribe.py rate edit/<id> measures it exactly on the rough cut after cut.py, per source and per segment (numbers written in digits are left out of both the vowels and the time, and it says how many);
  • editor intro, watermark, black frames at the start and end: leave them out;
  • below 720p: zoom no deeper than ~×1.06, get dynamics from cutaways and graphics, and say so right away;
  • was this source edited before: structure.py history <source> finds other edit/ folders with the same file; read their notes (what was chosen, what the person changed) before offering anything.
Step 2. Word-level transcript

With timings for every word; for two speakers, with speaker labels (on a single microphone they get mixed up, so identify speakers by their lips and write them into cut.json: "speaker" per range, "speakers" for a switch inside one; the kit then colors the subtitles per speaker in every mode, references/skit.md). Cache the transcript and do not rerun it. By default, locally with faster-whisper medium int8 (~2.5 min per 96 s of audio): transcribe.py edit/<id> <source> (cached in edit/<id>/transcripts/; your own tool gets the WAV from transcribe.py audio edit/<id> <source>, never the video file, and its output is checked with transcribe.py check); a cloud recognizer only if the person chose and connected it themselves (the video's audio then goes to that service; with the online add-on, addon.py transcribe lays a cloud text onto these local word times, the add-on's skill has the rules). All recognizers drift at word boundaries by 0.1–0.8 s, which is why cut edges are set by audio (step 6). Audio: edit/<id>/audio16k-<source stem>.wav, on the video's timeline (a phone MOV's sound track can start ~0.1 s after the picture; audio extracted without that lands every cut early and clips word endings); legacy audio16k.wav is still a valid speech-mask input.

Step 3. Takes and slips — before the plan

Speakers often record their lines in several takes, and Whisper merges a repeat into one stretched word. A missed take in the video looks like “the video jumps back”. Signs:

  1. a stretched word > ~1 s (a normal one is 0.2–0.7 s), especially with ≥ 0.3 s of silence inside; false alarms: a long first word often includes the silence before it, and a ~1 s word can include a pause before the word;
  2. a repeat in meaning of a phrase or its beginning;
  3. restart words: “so”, “I mean”, “that is”, “no”, “stop”, “let me start over”, or the same in the speaker's language; a cut-off word;
  4. a pause > 1 s mid-thought: often the seam between two attempts.

structure.py suggest also lists take candidates by the text (block “Takes”): two stretches that say the same words, an opening said again, a word said twice, each with source times, clean ranges and a confidence (high / medium / review). It finds pairs and never picks one: choose by the rules below and listen to each pair. A repeat Whisper merged into one word is not there (sign 1, retake?).

For a suspicious spot, cut out a segment no longer than 5 s, with a run-up from silence, and re-transcribe it separately (transcribe.py snip edit/<id> <source> --from … --to …: no context of the whole video, the transcript's language, a short sample of speech with fillers in that language as the prompt; a prompt in another language leaks into the text). On a 10-second segment the repeat still collapses. When the snip hears the spot right, put its words into the main transcript with transcribe.py splice edit/<id> edit/<id>/snip/<name>.json (they replace the words inside the snip's window; a backup <stem>.presplice.json is kept), then rebuild the cut. Transcribing the finished video as a whole structurally cannot see repeats.

Which take to use:

  • the speaker cancelled themselves out loud → discard the take;
  • the speaker approved themselves (“that one's good”) → use the previous take;
  • a whole phrase beats a broken one, even if the broken one is worded more precisely;
  • by default, the last take;
  • all broken → the most complete one; cover the joins with a shot-size change or a slide scene;
  • a slip corrected mid-phrase (“much more interesting, much more important”) → keep the corrected wording and cut the wrong one;
  • of two takes, the first goes out whole, together with its restart word (“so,”);
  • a long skit with whole trial runs and chatter between takes → take the last clean take whole and splice in good pieces from other takes only where needed;
  • clothing rustle can stay above the threshold for almost a second and look like speech; it is caught by an empty spot in the transcript and by the frames.

The cut edge is the start of the next take's sound minus 30–50 ms; check on the waveform that the first sound is not clipped. Unclear which take is better → put both in the plan and let the person decide. In the cut plan, list the takes and slips found, with source timecodes; if none were found, say so and list the signs that were checked.

Cutting a phrase out of continuous speech is possible only if there is ≥ 0.1 s of silence at both of its edges; no pause (a 50 ms dip) → cut it together with the neighboring phrase and say so in the plan. A noisy background (street, balcony, air conditioner, noise floor around −38 dBFS) is taken for speech by the speech detector, and edge-check warnings can be false; cross-check against the transcript (nothing there where the “speech” is) and by ear.

Where to place the edge:

  • in the longest silence between words, not at the first dip: a 30–60 ms dip in connected speech is inside a word, not a pause;
  • if the edge is followed by a short sound < 0.35 s, then silence ≥ 0.2 s, and only then speech, the short sound is the tail of the previous word; place the edge after the silence;
  • do not move an edge from the speech detector to match Whisper timing: Whisper drifts by 0.2–0.6 s; settle a disputed edge by looking at the waveform ±0.5 s;
  • do not cut between takes inside one phrase if neither take has ≥ 0.1 s of silence at the join; take the whole phrase from one take.

Whisper cannot see a word fragment at an edge in any mode: not on the whole file, not on a short segment, not with a prompt “with word fragments”. It does not drop the fragment; it attributes it to the word it expects, so the tail of a word at the start of a segment is recognized as the next word. Real case (Russian speech): the edge landed in a 40 ms dip inside poteryali (“lost”), the 0.23 s tail ‑(te)ryali got into the segment and was recognized as the following Na (“On”), and in the video teryali was heard twice, while the text-based checks were green. Only the audio-based edge check (step 6) catches this.

Step 3a. Structure: how it starts and ends — offered, not decided

The order of the lines is a choice of its own: the same speech works very differently with the strongest line first. Name the video's format, and its profile if it has one, in one line (section 5; the profile's start and ending rules: references/profiles.md), run structure.py suggest edit/<id> (--from/--to in source seconds when the video takes one fragment of a long recording; phrases with their signs, which can be cut out cleanly by audio, teaser candidates with exact ranges, a slow start, the payoff and ending, earlier edits of the source), read the transcript yourself (the script sees signs, not meaning), with two cameras run it per source (--source NAME, a name in cut.json → sources; before the cut list exists, --transcript edit/<id>/transcripts/<stem>.json) or on the main angle (it lists the sources rather than guess), and offer 2–3 structure variants as the first question of the cut plan's AskUserQuestion (step 5): each is start → middle → end with its length, why, and risk, with the order of lines and timecodes in the option's preview; the recommendation first. Start: in order · cut the slow start · teaser (a strong line from later plays first, then the video from its start) · proof first · question loop · detail first. Ending: payoff with a hold · CTA · logo sting · pull-out · callback to the hook · loop. A skit or a dialogue always gets a teaser variant; a teaser of the ending's payoff gives the punchline away, so say so. The menu with when and when not: references/structure.md. quick: no variants; the plan says “in order”, or names the found teaser or slow start in one line with the recommendation.

Step 4. Zoom margin and camera plan

A shot-size change is the main source of dynamics and the best way to hide a cut. Calculate before the plan:

  • by quality: below 720p → ~×1.06; 720p → up to ×1.28 (with lanczos upscaling + light sharpening); 1080p → ~×1.3; vertical 4K → up to ~×2.0 only with a rough cut at the source size (not verified; references/camera.md); horizontal 4K with a vertical crop → ~×1.12 (the vertical crop keeps 1215 px of width); the “framed” window first enlarges the source by window height ÷ source rows (×1.15 for 1080 rows, ×1.72 for 720), and the push-in counts on top of that base: 1080p leaves ≈ ×1.13, 720p and below ≤ ×1.06 (references/techniques.md);
  • by framing: in a close-up the top of the head is not cut off, the eyes are near the upper third, the chin is above the subtitles; with two people, two-shots only; a medium shot shifted toward one person is fine, a close-up on one cuts the other's face (references/skit.md).

A limit below ~×1.15 → the camera will not give any dynamics; say so before editing.

Step 5. Cut plan → “yes”

In one message with one AskUserQuestion (at most 4 questions: the structure variants of step 3a, the ending and CTA, the logo, the techniques with sound of step 7; the answers and the “yes” to the cut come together): start and ending (the variant chosen in step 3a, with the teaser's source timecodes if any), phrase order (what stays, what goes, what was rejected and why), takes and slips, pacing (“tight”: pauses up to 50 ms, speech_mask.py --density max, the default; “natural”: up to 220 ms, --density natural) and filler words (keep / remove; by default keep: speech sounds livelier), each with a recommendation, speed-up via atempo with pitch preserved (insight monologue ×1.15–1.25, skit and calm delivery ×1.1–1.15; above ×1.3 sounds rushed), final length, zoom margin, transcription fixes, and Supports (full; in quick and standard only the departures from a rule, one line each): the decisions that shape the video, each with the rule behind it (file › section or card ID, and its trust), what was not applied or departed from and why (references/playbook.md), opening with the line “Profile: · format ” (or “Profile: none · format ”). No cutting without a “yes”. The message looks like the cut plan in references/examples.md.

Multiple cameras: measure the speech rate for each source (syllables per second, step 1) and even them out with a separate speed for each; the rates that count are measured on the cut speech (transcribe.py rate edit/<id> after cut.py), adjust and rebuild. Real case: the sources measured 9.56 vs 7.55 syllables/s (27% apart) → ×0.915 and ×1.095, and the cut speech came out at 8.56 and 8.54; the source figures are only the first estimate. A take spoken faster than the rest shows up as one segment above the others: give it its own source name (the same file) with its own speed. No more than two phrases from the same angle in a row (count phrases, not the pieces a compressed pause splits a phrase into), and two in a row must differ in shot size; a phrase comes whole from one take; show the chain of angles in the plan.

Step 6. Rough cut — cut.py + cut.json

The video's cut list goes into edit/<id>/cut.json: sources (several cameras, each with its own speed), ranges (source segments with a beat), speed, look (brand LUT and its strength, a color filter chain), fix / fix_at (transcription fixes), retime (exact timings of main words), keep (phrases the subtitles never split), extract (cutaways from the same footage); format: references/scripts.md. cut.py edit/<id> --dry-run shows segments, lengths and words; cut.py edit/<id> builds final.mp4, captions.json (segments src_start/src_end/out_start/out_dur + words with start/end on the new timeline) and edl.json. The script encodes each segment separately with 30 ms audio fades at every cut and joins video and audio separately (a combined concat with AAC audio shifts the video start by ~21 ms, and Remotion then fails with “No frame found at position …”); it exits with code 1 unless video and audio both start at 0 and have the same duration.

Segment edges come from the audio, not the transcript (speech_mask.py; it prints the ranges for cut.json; the algorithm, verified: matches a manual cut to within ±40 ms):

envelope = RMS over 10 ms windows, dBFS
sdb      = rolling max of envelope over ±30 ms   # a dip inside a word does not become a pause
speech = sdb ≥ threshold AND the span lasts ≥ 110 ms   # a breath (−36…−42 dBFS) does not pass
threshold = −30 dBFS; for quiet recordings: min(−30, speech level p95 − 20 dB)
voiceless-ending pickup: a short burst within 250 ms after a span is part of the word
        (but the start of the next full span is a stop)
plosive-onset pickup: a short burst within 200 ms before a span is the start of its word (a 40 ms “p”, then the closure)
segment edge = first speech − 20 ms … last speech + 30 ms, snapped to the frame grid
pause compression: ≥160 ms → keep 50 ms (tight = --density max, the default; natural = --density natural: ≥400 → 220). Threshold no lower than 150 ms:
        a shorter unstressed syllable is indistinguishable from a pause
        (Russian example: “poka vy spite”, “while you sleep”, became “ka vy spite”)
warn: pause >1 s inside a segment (seam between takes); short speech at the start, then a pause (tail of another take)

The algorithm does not see meaningful silence (a smile at the end, a pause before a punchline); add it by hand. State the remaining silence as a number (≤ ~150 ms with “tight”).

Color (look in cut.json) in two steps: correction for the specific source (white balance, green cast, exposure; look.correct, applied before the LUT), then the “look”: your own LUT at 50–100% strength. White balance to neutral is measured in every video, not judged by eye: cut.py runs balance.py edit/<id> --write itself before its first build: the frames go through the same look, and look.correct gets the gains that make the grays of the graded result neutral (cut.json → balance records the look, sources, scale and ranges it was measured on, and the next cut.py measures again when the LUT, its strength, the grade, a source, the scale or the ranges change; a --ref measurement is only flagged, not redone; "balance": false in cut.json or --no-balance turns it off); check verify/balance.png (grays and skin). Measure the graded result, not the raw source: a brand LUT shifts the balance too (real case: it pulled blue down and the whole video read yellow; a correction before the LUT fixed it, the same LUT stayed). Always check verify/balance.png by eye; a frame dominated by colored light (sky or sea through windows, neon, mixed light), a refusal or no suggestion → balance.py edit/<id> --ref SECOND,X,Y,W,H --write on a white or gray object (white T-shirt, wall, paper; the box in pixels of the frame --still SECOND writes). An example look that works well on phone footage: eq=contrast=1.07:saturation=1.05, vibrance=0.13, curves=master='0/0 0.25/0.225 0.5/0.5 0.8/0.83 1/1'. vibrance above ~0.15 pushes skin toward orange. You can build your own LUT from an approved grade: ffmpeg -f lavfi -i haldclutsrc=8 -frames:v 1 -vf "<look chain>" look-hald8.png, then haldclut in ffmpeg (or convert the hald to .cube for CapCut). Strength via blending: split[a][b];[b][1:v]haldclut[l];[a][l]blend=all_mode=normal:all_opacity=0.7. ⟨YOURS: path to the brand LUT⟩

Speech leveling, in every video: cut.py brings the speech of every piece, and of every stretch inside a long piece, to one level, measured on the speech only (two takes in different places, a take closer to the phone, a speaker who leans back or turns away: each is heard as a jump, and the −14 LUFS mastering moves the whole track, not its parts). Pauses hold their gain, so room noise is not raised; ±8 dB at most, ±4 dB inside a piece, no faster than 3 dB/s. It prints the speech level per source before and after (real case: two locations 4.5 LUFS apart came out 0.2 apart, the pieces' spread fell from 7.7 to 0.9 dB, the pauses rose 0.5 dB). Off: "level": false in cut.json (a deliberate whisper, a scene played quiet); level.py edit/<id> --check measures a rough cut.

After assembling the rough cut, two mandatory checks, both before rendering:

  1. output subtitles: an identical run of 3+ words at adjacent cuts (a whole missed take): cut.py warns about it, in --dry-run too; a teaser replaying the same seconds is not flagged;
  2. the edges of all segments by audio (speech_mask.py --edl edit/<id>/edl.json: each segment's source is taken from edl.json, exit code 1 on warnings). The “edge inside a word” decision is made on the raw envelope, not on the mask: the mask widens speech by ±30 ms and stretches endings, so it would raise false alarms. What is checked:
check window 0.3 s on the far side of the edge; “loud window” = envelope ≥ threshold (10 ms windows)
edge inside a word : ≥15 loud windows within 0.3 s AND the nearest loud window ≤ 80 ms from the edge
                    → a 30–60 ms dip was taken for a pause; suggest an edge in the next silence
fragment at edge   : by the mask, the first speech span after the edge is shorter than 0.35 s, then silence ≥ 0.2 s
                    → tail of the previous word (or start of the next one, at the end); edge ≈ after the silence − 50 ms
edge too tight     : sound closer than 30 ms to the edge, with silence on the far side
                    → the cut fade (15–30 ms) will eat a consonant; move the edge by 40–50 ms

Each warning is a reason to listen and look at the waveform, not an automatic fix (“a short sound followed by silence” can also be a standalone short word, such as the Russian “A”, “and”). On verified videos: a clean cut gave 0 warnings in 7 segments; a multicamera cut gave 1 in 14, a real one (an edge tight against a “k”); the double teryali case is caught.

Then face measurement on final.mp4 (faces.py scan and zones, references/faces.md): faces.json (false “faces” on knees and hands dropped, with the count in the report) and zones per span. This feeds the camera plan (chin above the subtitles in close-ups), the brief (is there enough “headroom” zone for the chosen style) and the graphics layout. Picture defects, on request (the person, the preview or the board shows a face turned away, lost or blurred, or someone else in the frame): defects.py edit/<id> finds stretches where the sound is good and the picture is not (turned away or looking down, the face lost or blurred, someone else in the frame) → faces_defects.json; each one is covered in the visual plan or accepted with a reason (references/inserts.md, “Covering a bad stretch”).

Step 7. Graphics brief — in the cut plan's question (step 5)

The recommendation for this video goes first. Don't ask about what the prompt already says. At most 4 options per question, the most relevant ones.

  1. Logo, unless the series preset or the brand decides it: none / mark in the corner for the whole video / only on the end card / both. This answers where the logo is, not what the ending is: whether the end card carries a CTA is question 2.
  2. End card and CTA: up to 3 CTAs chosen by format, transcript and audience, the brand's own library (cta.md) first, then the plugin's (section 8), with the exact wording from the library (a text adapted to this audience is shown next to the original and called adapted). A CTA already spoken in the speech does not remove these options: it only adds the answers “a card on the spoken words”, “CTA by voice only”, and a logo sting (2.6 s, no CTA). An entertaining video can also end on its payoff with a hold and no card (the logo small over the last 1.5 s, if question 1 asked for one). The agent does not pick the CTA on its own (references/cta.md, “How to offer it”).
  3. Techniques (multiSelect). The kit draws: hook headline (with a teaser the line itself is the hook: offer one or the other) · hook as a question · punch-in · thesis cards (list, quote scenes) · full-screen phrase (slogan) · light flash (at an insert's or a scene's cut). Custom, a per-video composition and more time (offer only when the content asks for it): focus brackets on a word · role tags · verdict scale · “save” bookmark. Experimental (section 10) are not options: one line under the question names them (“also on request: text behind the person, presenter over a scene, phone mockup, slide scene, icon, message-thread and interface scenes, callouts on objects”), and one becomes an option only when this video's content clearly asks for it (callouts: objects named in the frame that the dot can stay on, still or tracked, the option naming them and their moments, references/callouts.md, “Offering it”). Recommend only what follows from the content. B-roll, code scenes, designed scenes and memes are not asked about here: they are turned on in step 0 and decided in the visual plan (step 7a); with designed scenes on, the hook, full-screen phrase, list and CTA are made as hook / slogan / list / cta scenes.
  4. Sound (inside the techniques question when four questions are already asked): none / sound accents on events / accents + music, with specific picks from the library (section 11); with music, duck the music under the main line or the CTA (master_audio.py --duck); the track's drop, its loud moment, is another thing and lands on the final phrase.

Answers go into the video's project.md; they are not inherited by the next video, except through a series preset (step 0). An answer about the brand as a whole (a ban, a preferred CTA, a format) goes into the brand folder instead (section 0). Do not silently resolve contradictory answers. If after the cut the chosen style doesn't fit the frame (for example no headroom for cards), say so here and offer a replacement.

Step 7a. Visual plan — insert decisions before rendering

All inserts off (use_broll, use_scenes, use_memes all false) → skip 7a: validate and stage create a plan without inserts themselves. Otherwise (references/inserts.md):

  1. visual_plan.py init edit/<id>: spans by phrase on the rough-cut timeline + hints (segment join, long segment, number, reference to an object, emotion, hook, CTA) + intensity budget. A “scenes only” promo has no rough cut: visual_plan.py init edit/promo-<brand> --scenes-only --duration 20 --brand <slug> (seconds, 15–25, best 18–22), then scenes at absolute times. Scenes over a recorded narration (“scenes + voice”): after cut.py cut the sound-only recording into voice.wav, visual_plan.py init edit/<id> --scenes-voice.
  2. Decide where an insert really helps: understanding, a cut, dynamics, the hook, or emotion for a meme. Each one gets a “what” and a “why”, with the moment given by a word (visual_plan.py add … --at "word:resume#1"). Numbers and lists go on cards or stat / list scenes; callouts chosen in step 7 go in as --kind callout on the words that name the objects; the ending and the CTA get no memes. Designed scenes (references/scenes.md) go in the same plan: gaps in the video suggest scene:*, text is verbatim from the speech or has a source, the default mode keeps the face (a slogan is full-screen), and the plan check enforces the reading-time floor and the brand tone's ceilings.
  3. Sources by priority (footage.py plan-search edit/<id>, memes.py search; an insert with no candidate is skipped with the way back, plan-search --retry or --insert ID --query "…"): B-roll: project → library → code scene → main footage; memes: your own folder and library → none. With the online-sources add-on it-reelsmaker-online installed, online sources join the chain, following the add-on's rules.
  4. Show the plan table to the person (visual_plan.py md) together with the card texts and, if any, the list of downloads (source, MB) and paid actions (≈ $). Wait for a “yes”.
  5. After the “yes”: take the footage (footage.py pick, which prepares it: 1080×1920, 30 fps, no audio, exactly the required length), make the code scenes (codescene.py scaffold → write the scene → render), prepare and place the memes (memes.py prepare, place: size and position by the rules, faces by the measurement), validate the plan (visual_plan.py validate, 0 errors; a picture defect is covered by an insert marked --covers dNN, or accepted) and hand it to Remotion (visual_plan.py stage). A brand mascot chosen in step 0 goes in the same plan: mascot.py mouth edit/<id>, then mascot.py plan edit/<id> --pose "word:…#1=point_left" on the words it reacts to, shown in the table; validate keeps it off the subtitles, the UI and the other graphics (references/mascot.md). Inserts that did not land (pending, skipped) do not go into the video: the main footage stays, and the reason goes into the report.
Step 8. Remotion

Start from the kit's ReelKit composition: brand.py stage <slug> --remotion {{REMOTION_DIR}} (the brand into the Remotion project, once per brand and after brand edits), then visual_plan.py stage edit/<id> --remotion {{REMOTION_DIR}} --props edit/<id>/reelkit-props.json [--hook "text"] (copies the rough cut to public/, writes brand, captions, inserts and scenes as props; --hook: a hook headline the kit shows for the first 2.4 s; the hook, --card/--sting and --corner are kept by later stages, --no-hook/--no-end/--no-corner take them off), then kit.py render edit/<id> [--concurrency 2] (it runs npx remotion render ReelKit in the Remotion project with the video's props, --out for another file than <remotion>/out/<id>.mp4; a run folder of its own for Remotion's temp files, removed afterwards, and a public/ of only this video's files); the cover is ReelCover with the same props (kit.py still edit/<id> --comp ReelCover --frame 0). The kit also draws the virtual camera (shots from edit/<id>/camera.json, references/camera.md), all three subtitle modes, a logo sting (stage --sting) and the “framed” format for a horizontal source (reelcfg.py save edit/<id> --set format=framed: the window, its caps label, the camera clamped to the window, scenes and subtitles inside it, or the subtitles under it with subtitles_at=below; references/techniques.md). Write a per-video composition only for what the kit does not cover, and reuse the kit's components in it. The kit draws the “Marker” (and v2) and “Brand” styles itself (the “Brand” focus brackets only inside stat, word and cta scenes: brackets on a word over the video need a per-video composition); “Minimal”, “Editorial”, “Bold” and “Glass” fall back to “Marker” with a warning, so they need a per-video composition (references/brands.md, “In Remotion”: styles, looks, fonts). The plan check times scenes by the kit's own animations (references/scenes.md, reading-time floor), so the composition keeps its entrances at or under them. Camera (section 9) → B-roll → only the chosen elements → memes → subtitles. Composition 1080×1920, 30 fps, as long as the video (plus the end card, if any). Each element enters on its own word, not in a batch. Card texts are written from the meaning of the line and shown before rendering: they almost always get edited.

  • The brand in code comes from the profile: colors brand.colors.*, fonts by family name, logos from the brand's assets/. Do not write HEX values or font names into the video's code.
  • Graphics positions come from the face-measurement zones (with the span's camera): hook and cards in the “headroom” zone or the “chest” zone, subtitles no higher than the recommended top. Record every card, hook and CTA card over the video in the plan as a keep_clear zone (interval + box + the span's camera): that way it is checked against the face right away, memes do not cover it, and the render audit sees it. A list in a close-up lacks “headroom” → raise the camera all the way to the top of the source (cy = 960 / z).
  • A phrase is one block (references/typography.md): lead-in tight against the big word, a shared axis, one coordinate system.
  • A cut-out figure on another scene or cutaway (references/figure.md): where the figure touches the edge of its source frame (arm, elbow, lower body), that edge must coincide with the edge of our frame; a chopped-off arm in the middle of the screen is a defect. Arm at the left edge of the source → the figure goes only against the left edge of the video; touches both sides or the top → do not put it in a corner. A source-edge cut can be hidden only by the frame edge or an opaque element on top, not by feathering.
Step 9. Check, render, mastering
  • before the full render, check.py edit/<id> (minutes, not the render's 8–10): the plan check, the storyboard sheet (board.py: a settled frame of every scene, insert, card, the hook and the end card, numbered, in edit/<id>/board/board-01.jpg with board.md; --shots a frame per camera shot, --transitions the middle of each smooth entrance) and the text check (textcheck.py, every 0.1 s in the browser: off the frame, two texts on top of each other, text on a measured face as errors; clipped by its box or in the UI zones as warnings); --comp Reel<id> for a per-video composition; exit code 1 if any fails. standard and full: show the board, the person answers by panel number, and the render runs after the “yes”; quick: the agent checks the board itself. The board and the text check need kit 1.10.0+ (a per-video composition wraps its content in <Sampled>);
  • hand stills (kit.py still edit/<id> --frame N) only for what the board does not show: a mid-transition frame without --transitions, a moment inside an insert (a meme reads and is off the face, B-roll has no third-party logos);
  • revisions as a defect table, before editing: timecode · object · what it does now · what it should do. The person's explicit note confirms its row; a vague one ("more dynamic") becomes rows only after a question (where, and what should change). Change only the agreed scope and leave working scenes as they are; defects the checks find are still reported and fixed as below. Use the late spot fix where it applies, then run the checks on the whole updated video, not only the fixed spots;
  • render → preview to the person → revisions → only then the master. kit.py render fails (exit 1) unless Remotion's exit code is 0 and the file is new and plays, and keeps the whole Remotion output in edit/<id>/render.log; don't chain render | tail && master around a bare npx: tail hides a render failure, and the master will silently be built from the old file;
  • a late spot fix that does not shift timing (a word in a subtitle, a card text, an element's position): not a full render but a re-render of a segment (patch_render.py out/<render>.mp4 --comp ReelKit --props <absolute path>/edit/<id>/reelkit-props.json --from … --to …; when the fix is in the props, run visual_plan.py stage … --props again first; --comp Reel<id> only for a per-video composition). The range is widened to the neighboring keyframes [K1, K2), Remotion draws only those (--frames=K1-(K2-1) --muted), and the segment is spliced in without re-encoding (if the codec parameters match) or with it; the audio is the old track, whole (if the fix touches audio, a full render is better: Remotion's audio render goes through all frames anyway, so the gain is small). Check: frame count and duration unchanged, timestamps even (every frame at n/fps; this is what catches “stutter”), frames at the joins compared with the old ones by frame number, not by time (PSNR ≥ 35 dB; for static neighboring frames the “best match” is random, so count it as a shift only if the neighboring frame is better by more than 1 dB), and the sheet of joins checked by eye. Measured on a one-minute video: full render 8–10 min, a ~100-frame patch without re-encoding 40–52 s (outside the patch, frames are bit-identical), with re-encoding ~2.5 min. Re-cutting, speed or length changes: full render only;
  • after the render, check.py edit/<id> --render out/<render>.mp4, before the person sees it: the faces audit of the render (faces.py audit, references/faces.md, section 5: faces after the camera against the subtitle band where speech is heard, the keep_clear zones and memes, a cut-off top of the head) and a 12-frame contact sheet edit/<id>/verify/sheet.png (does the picture change, is the top of the head cut off, does text cover the mouth); fix and re-render on a failure;
  • self-review before the preview: notes as time · where · problem → fix with P0/P1/P2, every join at ±0.2 s and the video at phone size (360 px wide), two rounds of fixes at most, then “passed with warnings”, except a P0 left: that stops the preview with a blocker report (references/examples.md, “Self-review”);
  • the cover, always, before the master: a settled frame in a pause of the speech, eyes open (poster.py pick --sheet, then --t; the person agrees on the frame; quick: the agent picks it, eyes open on the sheet, and shows it with the preview) → edit/<id>/cover.jpg, its text checked with poster.py guide (references/scenes.md, “Cover and frame 0”);
  • audio mastering with the cover, always (section 12): master_audio.py out/<render>.mp4 -o out/<brand>-<slug>-<date>-master.mp4 --cover edit/<id>/cover.jpg builds the one file that goes out without encoding the video again: the sound mastered, the cover embedded as cover art (the file manager's thumbnail, instead of a random B-roll frame), and …-cover.jpg next to it for uploading the cover by hand. Order: render → check.py edit/<id> --render … → poster.py pick → master_audio.py --cover. Without --cover it warns: a master without a cover is not delivered unless the person said so. The mastering has an acceptance check: failing any checklist item (LUFS, true peak, duration) → non-zero exit code; do not deliver the master. A “scenes only” promo with no voice and no music: effects over silence have no −14 LUFS target, the true peak and durations are checked, and --check reads the master's tag and applies the same rule (references/scenes.md).
Step 10. Delivery

Show measurable results, not “it got better” (format: the report in references/examples.md): duration, remaining silence in ms, master loudness and peak, how many cuts and takes were removed, how many inserts and from where (and which ones did not land, with the reason), and the Supports of the finished video (full; in quick and standard the profile, if any, and the departures only: the profile; decision → rule → trust; departures; the profile's checklist items skipped, by id), so a disliked result points to the rule to change. Found a defect nobody asked about → say so and fix it. Update project.md. On-screen facts need a source: a number, place, price, contact or promise comes from the speaker's words or from the client; anything the agent took on its own (from a website, “from general knowledge”, by default) goes into “open items” as “to verify”. Attribution for CC files (and stock footage, if any) goes into the post description. A post caption caption.txt (1–3 sentences in the brand voice, the same CTA) follows references/scenes.md, on a “yes” from {{APPROVER}}.

7. Two-person skit / “Verdict”

Role tags above the heads, a verdict scale, subtitles colored per speaker, a “save” bookmark, two-shots with rare punch-ins and a frame layout for two people: references/skit.md. A library, not a template: the scale only if the video is about an assessment.

8. CTA library ⟨YOURS: fill in contacts, remove what you don't need⟩

One CTA per video (exception: a job opening, with apply + recommend), a calm invitation with no “Urgent” or “Hurry up”, two lines on the card: the main line (52–60 px; the kit's full-frame end card draws it up to 64 px / 800) and a clarifier (34–38 px, in a muted color). The codes (dm, dm-word, comment-word, site, bio, apply, save, follow, …), their texts, audiences and formats: references/cta.md; a brand's own library (brands/<slug>/cta.md) is offered first. Promises only if they are kept; “Link in bio” only if the link is already there.

9. Virtual camera and word anchoring (Remotion)

The camera is { z, cx, cy } (scale and the frame point in the center), with shots listed in source time and converted by at(src), so a speed change in cut.py breaks nothing. Graphics are anchored to the spoken word (atWord(word, n)), matching ignoring edge punctuation and case. Code for both: references/camera.md.

  • drift: a slow push-in of +2–6% within a shot; whip: a 7-frame transition with Easing.out(cubic) and a sin(πp)·6 px blur, 1–3 times per video, never above the brand tone's ceiling (none for premium, up to 6 for bold; references/brands.md);
  • change shots on the pause between phrases, a shot lasts 1.5–3.5 s (playbook PACE-1); cycle wide → medium → close-up → medium; punch-in on the main point; CTA: close-up with a slow push-in; ending: pull-out;
  • on silence, a hard cut: a smooth transition over a pause reads as sluggish.

10. Special techniques (all per the brief)

Each only if the brief chose it; numbers, layouts, risks and which ones are not yet verified in a finished video: references/techniques.md (the cut-out itself: references/figure.md). Cut-out figure (experimental); text behind the person (experimental; only when the headroom can't hold the hook; the main risk is contrast); presenter over a scene (experimental; review, stream, window); the “framed” format for a horizontal source (a ~1030×1240 window); a phone mockup on the CTA (experimental); a light flash instead of a transition (within the brand tone's ceiling); a slide scene to cover choppy speech (experimental: the panel mode); a full-screen main phrase (1–2 per video, not on the hook or the CTA); callouts (experimental: a dot, a ring or a measuring line on an object, a leader line, a label or a number badge; still, on points, tracked by track.py or on a person; visual_plan.py add … --kind callout, references/callouts.md). LUT: see step 6.

Experimental (the techniques marked so above, the word / chat / ui scenes and the split / panel / window modes): the kit or the references have them, but none is checked in a finished video yet, so they are not in the menus. Offer one only where the content clearly asks for it, in the plan with the word “experimental” and a time estimate: the product is shown → ui or presenter over a scene; a message thread is retold → chat; a choppy take with a thesis → slide scene; the hook has no headroom → text behind the person; objects in the frame are named → callouts (a handheld shot: track.py). visual_plan.py md marks such scenes and modes; look at their storyboard frames before the full render. The person asks for one by name → do it as usual.

Designed scenes (references/scenes.md): hook, quote, slogan, number, list, before → after, CTA, cover (message thread, interface and word are experimental), drawn in code in brand colors, on a spoken word; the overlay mode keeps the face (as do the experimental split / panel / window), full within the brand tone's ceiling (1–3). A promo without footage is the “scenes only” format: 15–25 s, hook → reveal → 2–3 strong moments → ending/CTA, with no source analysis, transcript or cut. Scenes over your recorded narration is the “scenes + voice” format (references/scenes.md): the person records the voice on a phone (sound only), steps 2–6 run on it as on a video's sound (cut.py writes voice.wav instead of final.mp4), every scene is full, the voice is off camera (reel.json → voice: off_camera), its subtitles stay on over the scenes, length = the narration (past ~70 s, section 15).

11. Your own library of sounds, music and icons (optional)

An {{ASSETS_DIR}} folder with sounds, music, icons and memes, used through a catalog (sound start, loudness, background, brand verdict, overview sheets, a meme annotation; library_catalog.py --dir {{ASSETS_DIR}}), not by browsing files: references/library.md. In every video:

  • sound effects: only for what is seen, no more than one every 2–3 s, placed by the start of the sound, not of the file, one frame after the picture, 12–18 dB below voice peaks; no library → short sounds synthesized in code with ffmpeg (recipes in references/library.md);
  • icons: flat pictograms; service logos only when the service is named; {{FORBIDDEN_IMAGES}}, celebrities and film stills are a no; one at a time, 180–320 px, not on the face;
  • music: license first ⟨YOURS: {{ACCOUNT_TYPE}}⟩: a burned-in track needs a commercial license; the safe default is a render without music and a track picked in the app when publishing, or music composed in code for this video (music.py, yours, references/music.md).

12. Audio mastering — every video

Without mastering, finished videos came out between −33 and −17 LUFS, some with clipping. The speech is already leveled piece by piece in the rough cut (cut.py, step 6); mastering sets the loudness of the whole. Sound accents chosen in the brief go in here: the kit plays no sound, and master_audio.py mixes in the video's edit/<id>/sfx.json by itself (found next to --cover, or with --edit edit/<id>; --sfx <file> another file, --no-sfx none). The chain (script master_audio.py):

  • measure the noise floor → noise reduction (afftdn) only if the floor is louder than −50 dBFS: on a clean recording it causes artifacts;
  • highpass=f=80;
  • two-stage loudnorm to −14 LUFS, true peak −1 dBFS, linear=true (single-stage drifts off target); with no voice and no music (scenes only, effects over silence) no −14 target, the peak still ≤ −1 dBFS;
  • the audio is put into the render without re-encoding the video: -map 0:v:0 -map 1:a:0 -c:v copy -c:a aac -b:a 256k -movflags +faststart -shortest;
  • a final ebur128 measurement and a duration check against the video track (the render's audio can be a fraction of a second longer than the video).

Music, if burned in: level by the gap to the voice, sidechain, amix only with normalize=0 (otherwise the voice quietly drops), the music ducked under the main line (--duck), the track's drop on the final phrase, then −14 LUFS again: references/library.md, “Music in the mix”.

13. Pre-delivery checklist

  • The video has only what the brief chose; the brand comes from the profile (colors, fonts, logo); brand-level revisions are recorded in the brand folder (rules.md, cta.md, guide.md)
  • With a video profile, its checklist (references/profiles.md): visual_plan.py validate shows its automatic items succeeding (or the report says why not), the agent's items are confirmed on the draft, and the skipped ones are named by id (under Supports in full, in one line otherwise)
  • The storyboard sheet (board.py) was approved by number before the full render (quick: checked by the agent); textcheck.py shows 0 errors (warnings explained)
  • No text on a face: the render audit of faces shows 0 overlaps (subtitles, keep_clear cards, memes) + stills every ~2 s or the contact sheet; nothing in the UI zones (top 220, bottom 420, right 120 px)
  • Picture defects, if defects.py ran: each one covered (a full or code scene, a replacing B-roll or a cutaway, entering by a cut, 0.25 s around it) or accepted with a reason
  • Inserts (if on): each has a “why”, the intensity budget is kept, the plan was shown before rendering; B-roll has no third-party logos and no stock people “playing the client”; downloads and paid actions only after a “yes”, attribution recorded
  • Meme: on its line, rights known, no more than 460 px on the long side, at the edge of the frame, not over the face, subtitles or cards; no more than one full-frame meme
  • Graphics start on their word (±2 frames); hard cuts where there is silence
  • The picture changes every 1.5–3.5 s (an educational video may hold one idea longer, playbook PACE-1), checked on the plan, not by eye: list the spans longer than 3.5 s with no shot change, scene, card or insert and fill each one or say why it holds; close-ups are not blurry; the top of the head is not cut off
  • One style and one accent color; ≤ 6 words in a card or hook headline (designed scenes follow the reading-time floor); no outline or glow (unless the style calls for it)
  • A phrase is one block: parts of one thought tight together, shared axis, one zone; on a still at 25% size it reads as a single mass
  • Text is readable on a phone: the hook ≥ 92 px (≥ 76 in the “framed” window), cards ≥ 54 px, subtitles at the kit's sizes (Bar 60, Accent 66, Typewriter 56 px)
  • The logo is not distorted; on a dark background, the light (white) variant; there is one CTA (two for a job opening) and it works
  • No leftover takes or slips; no repeats at cuts; the first sound is not clipped; remaining silence stated as a number
  • All segment edges checked by audio (--edl): no edge inside a word, no fragments of neighboring words, no edges tight against sound
  • White balance measured on the graded result (balance.py): grays neutral, the correction before the LUT; skin natural on verify/balance.png
  • The cover is in the master as cover art (master_audio.py --check says “cover art: embedded”) and …-cover.jpg lies next to it and …-cover.jpg lies next to it
  • Speech leveled (cut.py printed “speech leveling”, the sources within ~1 dB) unless the brief kept a level on purpose; the sound accents chosen in the brief are in the master (the master printed “N sound(s) go into the master”)
  • Audio has no clicks; master at −14 ±0.7 LUFS (scenes only without voice or music: not required), peak ≤ −1 dBFS, duration = video, +faststart; the mastering acceptance check succeeded (code 0); in the rough cut, video and audio start_time = 0
  • Sound effects on their events; burned-in music only with a commercial license; with music, the voice is always louder
  • No icons with a “no” verdict; service logos only when the service is named
  • Special techniques: light flashes within the brand tone's ceiling (flash_max; 1–2 is typical); text behind the person reads without an outline, lead-in tight against the word; the mask check frame was reviewed (no furniture or wall); cut-out figure on a scene: not a single chopped-off arm inside the frame, face above the UI; skin looks natural after the LUT; no third-party data on the phone screen or in the scene
  • On-screen facts come from the speaker or the client; anything the agent sourced itself is in “open items”
  • Designed scenes (if any): within the brand tone; quotes verbatim, numbers sourced; reading-time floor kept; the face is not covered in overlay / split; settled and mid-transition frames reviewed; no slideshow (references/scenes.md, “No slideshow”)
  • The video makes sense without sound
  • edit/<id>/project.md is up to date: work log · strategy · brief · decisions · open items
  • Consent from the people on screen; publishing only after a “yes” from {{APPROVER}}

14. Shooting that makes editing possible (a memo for the speaker)

Vertical 4K with room above the head, side light, lines phrase by phrase in takes, 2–3 detail shots, a lavalier for each person in a skit: the memo to send before the shoot is references/shooting.md.

15. Machine limits ⟨YOURS⟩

On a laptop with 8 GB: one Remotion Studio at a time, videos up to ~60–70 s; longer than 90 s or a heavy figure cut-out needs a stronger machine (the online add-on can run the cut-out on your own server). Local Whisper: medium int8, not large (~1.6× the audio's length: a 90-minute recording ~2.3 h, in the background). Cut-out models: measure peak memory before running, and run them one at a time (references/figure.md). Remotion leaves its temp folders (a copy of public/ per run) behind on Windows: the plugin's commands remove their own, kit.py clean-temp lists the rest.

Remotion project dependencies: remotion, @remotion/cli, @remotion/google-fonts, @remotion/layout-utils (text width measurement); all @remotion/* packages at exactly the same version as remotion (npm install --save-exact @remotion/layout-utils@<remotion version>). Measure width only after the fonts have loaded (otherwise the fallback font's width gets cached).

Several agents at once in one editing folder are normal: write JSON (video settings, plan, indexes, profiles) atomically (temp file + replace) and under a lock over the read–modify–write cycle, with long operations (downloads, ffmpeg) outside the lock; don't touch other people's videos, edit shared Remotion files (Root.tsx, shared components) surgically, and put test compositions in a separate entry point and delete them after the check.

16. References — when to read

FileWhen
references/scripts.mdany step: which script does it, how to run it, the cut.json format
references/brands.mdstep 0 and any graphics: your settings in the project (reel-defaults.json, layers, CLAUDE.md), brand profiles and documents (rules, video guide, CTA library), a new brand from the minimum, logos, rules from revisions, styles in brand colors and in the kit, fonts, {{…}} placeholders
references/scenes.mdsteps 0, 7a, 8–10: designed scenes (catalog, modes, tones, fields, reading-time floor, facts, transitions, sound), promo without footage, cover, post caption; a sample component in references/scene-sample.md
references/mascot.mdsteps 0, 7a, 8: the brand mascot drawn in code (contract, poses, how to draw one, the mouth from the recorded narration, placement, motion, checks); a sample module in references/mascot-sample.md
references/inserts.mdstep 0 (inserts) and 7a: settings, intensity, when an insert is needed, priority and fallback, visual plan, modes and transitions, code scenes, memes: rights, size and placement
references/faces.mdsteps 6, 8, 9: face measurement with the YuNet model, false “faces” and the filter, zones for the hook, cards and subtitles accounting for the camera, card checks, render audit
references/figure.mdcut-out figure: the cut-out pipeline and model memory, check frame, presenter over a scene (layouts), source-edge cuts, text behind the person
references/typography.mdany on-screen text: a phrase as one block, gaps and line breaks, subtitles (contrast, splitting, when to hide), transcription
references/camera.mdstep 8: code for shots in source time (at) and graphics on the spoken word (atWord)
references/callouts.mdstep 7a: callouts on objects (experimental): when, the variants, points, tracking (track.py), a person, layout and motion, what validate checks
references/techniques.mdstep 7 techniques: text behind the person, presenter over a scene, framed format, phone mockup, light flash, slide scene, full-screen phrase
references/skit.md, references/cta.mda two-person skit; the CTA library for the end card and the cta scene (how to offer it, audience and format per CTA)
references/library.mdsection 11: your own library, its catalog, sounds for events, music in the mix
references/shooting.mdbefore the shoot: the memo for the speaker
references/profiles.mdstep 0 and before showing the draft: the video's profile and content format, their defaults under the brand tone, the brand's own tone for a profile, each profile's checklist with sources
references/structure.mdstep 3a: start, middle and ending mechanics (teaser, slow start, proof first, beat before the payoff, re-hook, payoff with a hold, callback, loop), how to offer them, a 20–30 s video in beats
references/examples.mdsteps 5, 9 and 10: what the cut plan, the self-review notes and the delivery report look like
references/no-speaker.mdstep 0 and 6 when the voice is not a person speaking in the frame: a voice-over over clips and photos, a talking head with a voice-over stretch, the no-speech reel (script.json, its timing, the sound question), the picture block, is the footage usable (picture.py scan hints), photos (EXIF, roi, no slideshow), color per place, strangers, the two-track contract (sound and picture apart)
references/music.mdmusic composed in code (music.py): styles, markers, the WAV, beats.json, how the plan and the master use it
references/longform.mda long recording → a series of clips: the brief, transcript or subtitles, reading by parts, the cards, the checks, the list, extract, the framed camera proposal, cost and limits
references/playbook.mdbefore the plan and at delivery: measurement vs taste, trust levels, the project playbook cards, conflicts, “Supports”, learning from a guide or a video, turning corrections into rules
references/pitfalls.mdsomething went wrong in steps 6–9: symptom → cause → what to do
references/migrations.mdstep 0: bringing older brand profiles and settings up to date
references/mascot-atlas.mda mascot from the brand's own character picture: what to bring, mascot_atlas.py, the check sheet, the limits of an overlay mouth
assets/brand-template/brand profile template (brand.json, rules.md, assets/); copy into {{PROJECT_ROOT}}/brands/<slug>/

评论

支持 Markdown