Overview
This skill orchestrates video strategy across the whole catalog — choosing which videos to make, in which format, for which audience, on which cadence. Use it when video production needs a plan before it needs a pipeline. It turns business goals into a video roadmap with measurable targets.
Video Strategy Orchestrator
Decides when to use Remotion, HyperFrames, AI video generation, or a hybrid. Evaluates input, complexity, determinism needs, and output format to pick the right engine.
When to Use
- User asks "which video tool should I use?"
- User wants to build a video pipeline and needs to choose the engine
- User has a video task and the tool is unspecified
- User wants to combine multiple video tools in one pipeline
- You're starting a video task in 1ai-content and need to decide the approach
When NOT to Use
- User explicitly names a tool (e.g., "use Remotion")
- User wants a specific HyperFrames workflow (use
video-production-orchestrator) - Task is clearly FFmpeg-only (format conversion, compression)
Workflow
1 · Identify input type
What is the source material?
- Existing React component → lean Remotion
- Product URL or brief → lean HyperFrames
- Text/article/topic → lean HyperFrames
- Text/image prompt → lean AI Video
- Existing footage → lean HyperFrames (talking-head-recut)
2 · Assess determinism need
- High (pixel-exact, branded, template-based) → Remotion or HyperFrames
- Low (creative, varied, experimental) → AI Video
3 · Evaluate complexity
- Complex logic/conditionals → Remotion
- Medium (DOM + CSS) → HyperFrames
- Simple (prompt only) → AI Video
4 · Check for hybrid opportunity
Can combining engines produce a better result?
- AI generates content + HyperFrames adds timing → HYBRID
- Remotion template + HyperFrames overlays → HYBRID
5 · Route and justify
State the chosen engine(s) and why (one sentence).
The Three Engines
1. Remotion (React-Based Rendering)
What: React components → video via headless Chrome + FFmpeg
Strengths:
- Component reusability (React ecosystem)
- Complex logic (hooks, state, conditional rendering)
- Type safety (TypeScript)
- Existing template library (
ProductAd.tsx,ProductAd-Hook) - Deterministic output
Weaknesses:
- React learning curve for agents
- Verbose for simple animations
- Harder to generate from scratch via LLM
- Bundle size (React + Remotion runtime)
Best for:
- Template-based product ads (existing compositions)
- Videos requiring complex logic/conditionals
- When you have a React component library
- When TypeScript safety matters
2. HyperFrames (HTML→MP4)
What: HTML + CSS + seekable animations → deterministic MP4
Strengths:
- Agent-native (LLMs write HTML best)
- Simpler than React for most video tasks
- Built-in transition catalog (cut-the-curve, zoom-through, etc.)
- Design system support (frame.md)
- Lower-level control (direct DOM manipulation)
Weaknesses:
- No component model (plain HTML files)
- Manual state management
- Less suited for complex interactivity
- Newer ecosystem (fewer templates)
Best for:
- Product launch videos from URLs
- Motion graphics and kinetic type
- Talking-head recut with overlays
- Faceless explainers
- Changelog/digest videos
- When the agent generates the composition
3. AI Video Generation (Prompt-Based)
What: Text/image prompt → AI-generated video
Strengths:
- Creative output (invented visuals)
- No manual animation work
- Fast iteration (prompt → video)
- Good for abstract/conceptual content
Weaknesses:
- Stochastic (different output each time)
- Limited control over exact timing
- No deterministic output (can't pixel-match)
- Provider-dependent quality
- Cost per generation
Best for:
- Creative/experimental content
- Abstract explainers
- Social media content (variety over precision)
- When exact timing doesn't matter
Decision Matrix
| Factor | Remotion | HyperFrames | AI Video |
|---|---|---|---|
| Input type | React component | HTML/template | Text/image prompt |
| Determinism | High | High | Low |
| Complexity | High (hooks, state) | Medium (DOM + CSS) | Low (prompt only) |
| Agent-friendliness | Medium | High | High |
| Reusability | High (components) | Medium (templates) | Low (prompts) |
| Timing control | Frame-exact | Frame-exact | Approximate |
| Existing templates | Yes (ProductAd) | Yes (frame presets) | N/A |
| Best for | Template-based ads | Agent-generated videos | Creative/experimental |
When to Use Each
Use Remotion When:
- You have an existing React composition (e.g.,
ProductAd.tsx) - The video requires complex logic (conditional rendering, data fetching)
- You need TypeScript safety
- You're extending an existing Remotion project
- The user explicitly asks for Remotion
Use HyperFrames When:
- The agent generates the composition from scratch
- You need a product launch video from a URL
- You want motion graphics, kinetic type, or logo stings
- You need a talking-head recut with overlays
- You want a faceless explainer
- You need a changelog/digest video
- The user wants HTML-based video
Use AI Video Generation When:
- The content is abstract or conceptual
- Exact timing doesn't matter
- You want creative variety (multiple versions)
- The user provides a prompt, not a script
- You're generating social media content (TikTok/Reels)
- The user says "generate a video from this idea"
When to Combine (Hybrid Pipelines)
Pattern 1: AI → HyperFrames (Enhance AI output)
Use when: Generate base content with AI, then add precise timing/overlays with HyperFrames.
1. AI video generation → base footage
2. HyperFrames → add kinetic captions, lower-thirds, brand overlays
3. FFmpeg → final assembly
Example: Generate an explainer with AI, then add synced captions and a branded intro/outro with HyperFrames.
Pattern 2: Remotion → HyperFrames (Template + Overlay)
Use when: Render a Remotion composition, then overlay with HyperFrames.
1. Remotion → render product ad (deterministic, branded)
2. HyperFrames → add talking-head overlay, captions, or data callouts
3. FFmpeg → composite layers
Example: Render a ProductAd with Remotion, then add a talking-head narrator and captions with HyperFrames.
Pattern 3: HyperFrames → AI (Fill gaps)
Use when: Build the structure with HyperFrames, then fill gaps with AI-generated content.
1. HyperFrames → build intro, outro, and transition structure
2. AI video → generate middle scenes (abstract/experimental)
3. HyperFrames → stitch everything together with precise timing
Example: Create a branded intro/outro with HyperFrames, generate the middle explainer content with AI, then assemble with HyperFrames transitions.
Pattern 4: AI → Remotion (Data-driven templates)
Use when: Generate data/content with AI, then render with Remotion templates.
1. AI → generate product descriptions, pricing, reviews
2. Remotion → render ProductAd template with AI-generated data
3. Output → deterministic, branded video
Example: Scrape product reviews with AI, then render a Remotion product ad with the data.
Routing Logic
START: What's the input?
├── Existing React component → REMOTION
├── Product URL + "launch video" → HYPERFRAMES (product-launch-video)
├── Existing footage + "add graphics" → HYPERFRAMES (talking-head-recut)
├── Text/article + "explainer" → HYPERFRAMES (faceless-explainer)
├── "motion graphics" / "logo sting" → HYPERFRAMES (motion-graphics)
├── "changelog" / "digest" → HYPERFRAMES (changelog-video)
├── "captions" / "subtitles" → HYPERFRAMES (embedded-captions)
├── Text prompt + "creative" → AI VIDEO GENERATION
├── "social media" + "variety" → AI VIDEO GENERATION
├── Need precise timing + creative content → HYBRID (AI + HyperFrames)
├── Have template + need overlays → HYBRID (Remotion + HyperFrames)
└── Unclear → Ask: "Do you need precise timing or creative variety?"
Anti-Rationalization Table
| Rationalization | Reality |
|---|---|
| "I'll always use HyperFrames, it's agent-native" | Remotion is better for existing React templates |
| "I'll always use AI, it's faster" | AI is stochastic — bad for precise timing |
| "I'll always use Remotion, it's more powerful" | HyperFrames is simpler for agent-generated content |
| "I'll use all three for every video" | Over-engineering — pick the minimum viable engine |
| "I'll skip the orchestrator and just pick one" | Wrong tool = wasted effort. Evaluate deliberately. |
| "Hybrid is always better" | Hybrid adds complexity — only combine when necessary |
Verification
- Input type identified (component, URL, text, prompt)
- Determinism requirement assessed (high/low)
- Complexity evaluated (simple/medium/complex)
- Engine chosen with justification
- If hybrid, combination pattern documented
- User didn't have to pick the tool (orchestrator decided)