home / skills / yonatangross / orchestkit / video-storyboarding

video-storyboarding skill

/plugins/ork/skills/video-storyboarding

This skill plans compelling tech demonstration videos using AIDA, scene templates, and shot timing to streamline pre-production and storytelling.

npx playbooks add skill yonatangross/orchestkit --skill video-storyboarding

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
9.1 KB
---
name: video-storyboarding
description: Pre-production planning for tech demo videos using AIDA framework, scene templates, and shot planning for compelling narratives
tags: [video, storyboard, pre-production, planning, narrative, remotion]
user-invocable: false
version: 1.0.0
---

# Video Storyboarding for Tech Demos

Pre-production planning system for creating compelling tech demo videos. Combines the AIDA marketing framework with structured scene planning.

## Overview

```
┌─────────────────────────────────────────────────────────────────┐
│                    VIDEO PRODUCTION PIPELINE                     │
├─────────────────────────────────────────────────────────────────┤
│  ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐     │
│  │ CONCEPT  │──▶│STORYBOARD│──▶│  ASSETS  │──▶│  RENDER  │     │
│  │          │   │          │   │          │   │          │     │
│  │ • AIDA   │   │ • Scenes │   │ • Code   │   │ • Export │     │
│  │ • Hook   │   │ • Timing │   │ • B-roll │   │ • Review │     │
│  │ • CTA    │   │ • Shots  │   │ • Audio  │   │ • Publish│     │
│  └──────────┘   └──────────┘   └──────────┘   └──────────┘     │
└─────────────────────────────────────────────────────────────────┘
```

## AIDA Framework for Tech Demos

The AIDA framework structures your video to guide viewers from awareness to action.

### Framework Timeline

```
┌─────────────────────────────────────────────────────────────────┐
│                         AIDA TIMELINE                            │
├─────────────────────────────────────────────────────────────────┤
│  0s              15s              45s              75s    90s   │
│  │───────────────│────────────────│────────────────│──────│    │
│  │   ATTENTION   │    INTEREST    │     DESIRE     │ACTION│    │
│  │    (15%)      │     (35%)      │     (35%)      │(15%) │    │
│                                                                  │
│  Emotion: Curious   Engaged        Convinced        Motivated   │
└─────────────────────────────────────────────────────────────────┘
```

### Phase Summary

| Phase | Duration | Goal | Content |
|-------|----------|------|---------|
| **A - Attention** | 10-15s | Stop the scroll | Bold claim, visual impact, pattern interrupt |
| **I - Interest** | 30-40s | Demonstrate value | Problem setup, solution intro, feature highlights |
| **D - Desire** | 30-40s | Build connection | Benefits, social proof, differentiation |
| **A - Action** | 10-15s | Drive conversion | Clear CTA, next steps, closing |

### Anti-Patterns to Avoid

```
❌ Logo animations (skip these)
❌ Slow fade-ins
❌ Generic stock footage
❌ Reading from slides
```

## Scene Planning Template

```yaml
# scene-001-hook.yaml
scene:
  id: "001"
  name: "Hook"
  phase: "attention"

timing:
  start: "00:00"
  duration: "00:08"
  end: "00:08"

content:
  narration: |
    What if you could give Claude Code
    the memory of a senior developer?

  on_screen_text:
    - text: "179 Skills"
      animation: "scale-in"
      timing: "0:02-0:04"

visuals:
  background: "dark gradient"
  main_element: "animated skill icons"

transitions:
  in: "cut"
  out: "fade"

assets_required:
  - "skill-icons-spritesheet.png"
  - "claude-logo.svg"
```

## Timing Calculations

### Video Length Guidelines

| Platform | Optimal | Max | Notes |
|----------|---------|-----|-------|
| Twitter/X | 30-45s | 2:20 | Hook in 3s |
| LinkedIn | 30-90s | 10:00 | Value in 15s |
| YouTube Shorts | 30-60s | 60s | Vertical only |
| YouTube | 2-5 min | No limit | Longer = better |
| Product Hunt | 1-2 min | 3:00 | Demo focused |
| GitHub README | 30-60s | 2:00 | Silent-friendly |

### Pacing Calculator

```typescript
interface VideoTimingConfig {
  totalDuration: number; // seconds
  phases: {
    attention: number;  // percentage
    interest: number;
    desire: number;
    action: number;
  };
}

function calculatePhaseTiming(config: VideoTimingConfig) {
  const { totalDuration, phases } = config;

  return {
    attention: {
      start: 0,
      duration: Math.round(totalDuration * phases.attention / 100),
    },
    interest: {
      start: Math.round(totalDuration * phases.attention / 100),
      duration: Math.round(totalDuration * phases.interest / 100),
    },
    // ... desire and action phases
  };
}

// Example: 90 second video
const timing = calculatePhaseTiming({
  totalDuration: 90,
  phases: { attention: 15, interest: 35, desire: 35, action: 15 }
});
```

### Words Per Minute Guide

| Speaking Speed | WPM | Words/30s | Use Case |
|----------------|-----|-----------|----------|
| Slow (dramatic) | 100 | 50 | Hooks, reveals |
| Normal | 130 | 65 | Explanations |
| Fast (excited) | 160 | 80 | Features list |
| Very Fast | 180+ | 90+ | Avoid (unclear) |

## Shot List Template

```
┌──────┬──────────┬─────────────────────────┬─────────┬────────────┐
│ Shot │ Duration │ Description             │ Type    │ Assets     │
├──────┼──────────┼─────────────────────────┼─────────┼────────────┤
│ 001  │ 0:03     │ Logo reveal             │ Motion  │ logo.svg   │
│ 002  │ 0:05     │ Hook text animation     │ Kinetic │ font.otf   │
│ 003  │ 0:08     │ Terminal demo           │ Screen  │ demo.mp4   │
│ 004  │ 0:12     │ Feature walkthrough     │ Screen  │ capture.mp4│
│ 005  │ 0:05     │ CTA with command        │ Static  │ bg.png     │
│TOTAL │ 0:33     │                         │         │            │
└──────┴──────────┴─────────────────────────┴─────────┴────────────┘
```

## Storyboarding Workflow

```
1. DEFINE GOAL
   └─▶ What action should viewers take?
       └─▶ Example: "Install OrchestKit"

2. IDENTIFY AUDIENCE
   └─▶ Who is watching?
       └─▶ Example: "Developers using Claude Code"

3. CRAFT HOOK
   └─▶ What stops the scroll?
       └─▶ Example: "179 skills, one command"

4. MAP AIDA PHASES
   └─▶ Allocate time to each phase
       └─▶ Calculate scene durations

5. WRITE SCENES
   └─▶ Detail each scene with template
       └─▶ Include narration, visuals, timing

6. CREATE SHOT LIST
   └─▶ Break scenes into individual shots
       └─▶ Identify all required assets

7. PLAN B-ROLL
   └─▶ List all supplementary footage
       └─▶ Schedule capture sessions

8. REVIEW & ITERATE
   └─▶ Check timing, flow, message clarity
```

## Remotion Integration

```typescript
interface StoryboardScene {
  id: number;
  phase: 'attention' | 'interest' | 'desire' | 'action';
  timing: string;
  narration: string;
  text: string | null;
}

function sceneToReaction(
  scene: StoryboardScene,
  fps: number = 30
): { component: string; durationInFrames: number } {
  const [start, end] = scene.timing.split('-').map(parseTime);
  const durationSeconds = end - start;

  return {
    component: `Scene${scene.id}`,
    durationInFrames: Math.round(durationSeconds * fps),
  };
}

function parseTime(time: string): number {
  const [mins, secs] = time.split(':').map(Number);
  return mins * 60 + secs;
}
```

## Related Skills

- `video-pacing`: Rhythm and timing rules
- `elevenlabs-narration`: TTS integration
- `content-type-recipes`: Production recipes by content type
- `remotion-composer`: Programmatic video generation

## References

- [AIDA Framework](./references/aida-framework.md) - Deep dive into AIDA psychology
- [Scene Templates](./references/scene-templates.md) - Copy-paste scene templates
- [Pre-Production Checklist](./references/pre-production-checklist.md) - Complete checklist

Overview

This skill designs pre-production plans for tech demo videos using the AIDA marketing framework, scene templates, and shot planning. It turns product features and target-audience goals into timed scenes, narration, and an asset-ready shot list. The output is actionable: YAML scene files, pacing calculations, and Remotion-friendly timing conversions.

How this skill works

It maps a target video length into AIDA phases (Attention, Interest, Desire, Action) and calculates scene durations and start times. It generates scene templates with narration, on-screen text, visuals, transitions, and required assets. It also produces shot lists, pacing guidelines, and small TypeScript helpers to convert scene timing into frames for programmatic rendering.

When to use it

  • Planning short social demos (30–90s) where hook and tempo matter
  • Producing longer product walkthroughs with clear AIDA phase allocation
  • Creating reusable scene templates and asset lists before production
  • Translating storyboard timing into frames for Remotion or programmatic render pipelines
  • Coordinating multiple contributors: developer demos, voice talent, and editors

Best practices

  • Start by defining a single measurable CTA so every scene drives one outcome
  • Design a scroll-stopping hook in the first 3–15 seconds—use bold visuals or a surprising claim
  • Allocate time by AIDA percentages (e.g., 15/35/35/15) and validate with the pacing calculator
  • Write narration at target WPM (100–160) and test read-throughs to tune scene lengths
  • List all required assets per scene (video, sprites, fonts, audio) to avoid mid-production gaps
  • Avoid anti-patterns: no long logo animations, slow fade-ins, or overuse of generic stock footage

Example use cases

  • 30s Twitter/X demo that hooks viewers with a bold developer benefit and a one-line CTA
  • 90s LinkedIn product demo that uses Interest and Desire phases to show before/after workflows
  • 2–5 minute YouTube walkthrough that expands Desire with social proof and live terminal captures
  • Programmatic render pipeline: convert YAML scenes to Remotion components using sceneToReaction helpers
  • Cross-functional shoot planner: share shot list and asset checklist with editors and voice actors

FAQ

What output formats does the skill produce?

Scene YAML templates, shot lists, pacing calculations, and small TypeScript helpers for converting timing to frames.

How do I choose total video length for a platform?

Follow platform guidelines: 30–45s for Twitter/X, 30–90s for LinkedIn, 2–5 min for YouTube; use the pacing calculator to split AIDA phases.

Can this integrate with programmatic video tools?

Yes. Templates are designed to convert to Remotion-friendly components and include timing utilities for frame calculations.