# Final Motion Hybrid Rendering

Use this pattern for mechanism-reveal Shorts where clarity matters more than cinematic generation.

## Core rule

AI image/video provides only text-free atmosphere and motion texture. The deterministic renderer owns all truth-bearing layers:

- captions and subtitles;
- UI/email/card text;
- arrows, labels, numbers, and diagrams;
- factual claims and final assembly.

Do not ask an image/video model to spell workflow labels or explain the mechanism. It will eventually produce fake UI text, malformed words, or pretty but unclear motion.

## Recommended pipeline

```text
Final voiceover script
→ final video plan / scene timeline
→ scene-specific text-free image prompts
→ procedural motion renderer overlays
→ TTS voiceover
→ compact phrase-boundary subtitles
→ FFmpeg final assembly
→ visual QA frames
```

## Scene-specific ChatGPT Image/Codex backgrounds

When the user points out that ChatGPT Image is available through Codex, prefer it for fast text-free keyframe/background texture before reaching for local Qwen Image/ComfyUI. Local Qwen/ComfyUI remains useful for private/local batches or cost control, but for this class of mechanism-reveal prototype the lowest-friction path is often:

```text
ChatGPT Image/Codex background(s)
→ deterministic renderer overlays
→ FFmpeg assembly
```

For each production scene, create one background prompt that explicitly says:

```text
Vertical 9:16 cinematic background
No readable text
No logos
No watermarks
No UI labels
No fake letters
Leave central negative space for renderer-owned overlays
```

Use scene-specific mood, not baked-in explanations:

- clean demo: calm laptop/workspace/dashboard glow;
- weird input: slightly messy email-workflow atmosphere, amber warning mood;
- wrong routing: abstract AI path energy, subtle red warning tension;
- mechanism split: minimal dark technical background with space for diagram overlay;
- final rule: calm premium blue/green tech background.

Store generated media outside Git; commit only plans, prompts, tests, and docs.

## Renderer-owned mechanism overlays

A good beginner-friendly AI-systems Short should make the mechanism visible. Example pattern:

```text
Clean demo
→ weird email appears
→ AI confidently routes it wrong
→ three-way split:
   Normal → Go through
   Unclear → Review
   Weird/Risky → Stop
→ final rule
```

Render labels, arrows, cards, and captions locally. Check that arrows sit behind labels and that subtitles do not obscure the diagram.

## Subtitle polish for final-motion videos

Use compact phrase-boundary subtitles for final-near renders:

- 1–4 word cues;
- split on semantic punctuation where possible;
- smaller than preview captions;
- placed high enough above bottom UI/safe zones;
- avoid cross-clause chunks like `ANYTHING DECIDE THREE`.

For a 1080x1920 ASS burn-in baseline, a useful starting point is:

```text
Fontsize: 72
MarginV: 320
Max lines: 2
```

Always inspect at least one critical mechanism frame after subtitle burn-in before exporting or sending.

## Approval package after first-public export

Once a 1080x1920 candidate exists, do not stop at "video rendered". Prepare a side-effect-free final approval package before any delivery/platform step:

```text
media path
SHA256 checksum
platform labels
title variants
caption + hashtags
hook
final/review language metadata
quality notes
approval commands
```

Guardrails:

- `requires_human_approval=True`
- `side_effects=()`
- no Telegram/platform calls inside the package builder
- no implicit action words like `publish` or `post`
- verify the checksum and ffprobe metadata from the actual file before presenting approval metadata

This turns a rendered MP4 into an auditable review artifact instead of a loose file path.

## QA gates

Before treating a render as a first-public candidate, verify:

- first 2 seconds communicate the concrete problem;
- top text, subtitles, and voiceover come from one source of truth;
- no generated image contains readable fake text/logos;
- mechanism labels are readable on mobile;
- subtitles do not compete with the core diagram;
- audio and video durations match closely;
- generated media remains ignored by Git.