Create Video Start

Create Video Start

Master orchestrator skill that chains the entire Remotion video pipeline together. Takes a single creative brief and automatically invokes each specialized skill in sequence, passing outputs between them.

What This Skill Does

Orchestrates the complete video creation pipeline:

1. motion-designer → Creates VIDEO_SPEC.md from creative brief 2. remotion-scaffold → Sets up project structure 3. remotion-animation → Generates animation configurations 4. remotion-composition → Creates Sequence layout 5. remotion-component-gen → Generates each scene component 6. remotion-render-config → Configures output settings 7. remotion-asset-coordinator → Prepares asset manifest

Pipeline Execution

When invoked, execute this pipeline in order:

Step 0: Setup

Create a working directory for pipeline artifacts:

# Create pipeline working directory
PIPELINE_DIR=".remotion-pipeline/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$PIPELINE_DIR"
echo "Pipeline artifacts: $PIPELINE_DIR"

Step 1: Motion Designer → VIDEO_SPEC.md

Generate the motion design specification from the creative brief:

# Invoke motion-designer skill
claude -p "You are using the /motion-designer skill.

Create a detailed VIDEO_SPEC.md for this creative brief:

$CREATIVE_BRIEF

Output a complete motion design specification with:
- Overview (duration, fps, dimensions)
- Color palette with hex codes
- Scene-by-scene breakdown with timing
- Animation details for each element
- Audio specifications

Write the spec to: $PIPELINE_DIR/VIDEO_SPEC.md" \
  --allowedTools "Read,Write,Edit,Bash"

Checkpoint: Verify VIDEO_SPEC.md exists and contains all required sections.

Step 2: Remotion Scaffold → SCAFFOLD_MANIFEST.md

Create project folder structure:

# Invoke remotion-scaffold skill
claude -p "You are using the /remotion-scaffold skill.

Based on this VIDEO_SPEC.md:
$(cat $PIPELINE_DIR/VIDEO_SPEC.md)

Create the Remotion project scaffold:
1. Create folder structure for the composition
2. Create empty template files
3. Setup asset directories
4. Register composition in Root.tsx

Write manifest to: $PIPELINE_DIR/SCAFFOLD_MANIFEST.md
Write actual files to the project." \
  --allowedTools "Read,Write,Edit,Bash,Glob"

Checkpoint: Verify scaffold directories and files exist.

Step 3: Remotion Animation → ANIMATION_CONFIG.md

Generate animation configurations:

# Invoke remotion-animation skill
claude -p "You are using the /remotion-animation skill.

Based on this VIDEO_SPEC.md:
$(cat $PIPELINE_DIR/VIDEO_SPEC.md)

Generate animation configurations:
1. Spring configs for each animation type
2. Interpolation mappings
3. Timing constants
4. Stagger delay patterns

Write to: $PIPELINE_DIR/ANIMATION_CONFIG.md

Output TypeScript constants that can be copied to constants.ts" \
  --allowedTools "Read,Write,Edit"

Checkpoint: Verify ANIMATION_CONFIG.md contains spring configs and timing.

Step 4: Remotion Composition → COMPOSITION_STRUCTURE.md

Generate Sequence layout:

# Invoke remotion-composition skill
claude -p "You are using the /remotion-composition skill.

Based on this VIDEO_SPEC.md:
$(cat $PIPELINE_DIR/VIDEO_SPEC.md)

Generate composition structure:
1. Sequence ordering for all scenes
2. Transition timing between scenes
3. Duration calculations
4. Scene timing constants

Write to: $PIPELINE_DIR/COMPOSITION_STRUCTURE.md

Output the main composition JSX structure." \
  --allowedTools "Read,Write,Edit"

Checkpoint: Verify COMPOSITION_STRUCTURE.md contains Sequence layout.

Step 5: Remotion Component Gen → SCENE_COMPONENT.md (per scene)

Generate each scene component:

# For each scene in the spec, invoke remotion-component-gen
for SCENE_NUM in $(seq 1 $TOTAL_SCENES); do
  claude -p "You are using the /remotion-component-gen skill.

Based on Scene $SCENE_NUM from this VIDEO_SPEC.md:
$(cat $PIPELINE_DIR/VIDEO_SPEC.md)

And these animation configs:
$(cat $PIPELINE_DIR/ANIMATION_CONFIG.md)

Generate the complete Scene${SCENE_NUM} component:
1. Full TSX implementation
2. Animation logic using the configs
3. Proper imports and types
4. AbsoluteFill wrapper

Write to: $PIPELINE_DIR/SCENE_${SCENE_NUM}_COMPONENT.md
Also write the actual .tsx file to the scenes/ folder." \
    --allowedTools "Read,Write,Edit,Glob"
done

Checkpoint: Verify all scene components are generated.

Step 6: Remotion Render Config → RENDER_CONFIG.md

Generate render settings:

# Invoke remotion-render-config skill
claude -p "You are using the /remotion-render-config skill.

Based on this VIDEO_SPEC.md:
$(cat $PIPELINE_DIR/VIDEO_SPEC.md)

Generate render configuration:
1. Output format and codec settings
2. Quality settings
3. Resolution confirmation
4. Render command examples

Write to: $PIPELINE_DIR/RENDER_CONFIG.md" \
  --allowedTools "Read,Write,Edit"

Step 7: Remotion Asset Coordinator → ASSET_MANIFEST.md

Generate asset preparation guide:

# Invoke remotion-asset-coordinator skill
claude -p "You are using the /remotion-asset-coordinator skill.

Based on this VIDEO_SPEC.md:
$(cat $PIPELINE_DIR/VIDEO_SPEC.md)

And this SCAFFOLD_MANIFEST.md:
$(cat $PIPELINE_DIR/SCAFFOLD_MANIFEST.md)

Generate asset manifest:
1. List all required assets
2. Recommend sources for each
3. Provide preparation instructions
4. Generate import code snippets

Write to: $PIPELINE_DIR/ASSET_MANIFEST.md" \
  --allowedTools "Read,Write,Edit,WebSearch"

Step 8: Assemble Final Output

Combine all outputs into final summary:

# Create final summary
claude -p "Create a PIPELINE_COMPLETE.md summary that:

1. Lists all generated files
2. Provides next steps for the developer
3. Includes quick-start commands
4. Notes any TODOs that need manual attention

Pipeline artifacts:
- VIDEO_SPEC.md: $(cat $PIPELINE_DIR/VIDEO_SPEC.md | head -20)
- SCAFFOLD_MANIFEST.md: $(cat $PIPELINE_DIR/SCAFFOLD_MANIFEST.md | head -20)
- ANIMATION_CONFIG.md: $(cat $PIPELINE_DIR/ANIMATION_CONFIG.md | head -20)
- COMPOSITION_STRUCTURE.md: $(cat $PIPELINE_DIR/COMPOSITION_STRUCTURE.md | head -20)
- Scene components: $(ls $PIPELINE_DIR/SCENE_*_COMPONENT.md)
- RENDER_CONFIG.md: $(cat $PIPELINE_DIR/RENDER_CONFIG.md | head -20)
- ASSET_MANIFEST.md: $(cat $PIPELINE_DIR/ASSET_MANIFEST.md | head -20)

Write to: $PIPELINE_DIR/PIPELINE_COMPLETE.md" \
  --allowedTools "Read,Write,Edit,Glob"

Input Format

Creative Brief (Natural Language)

Create a 30-second product demo video for Vello, an AI task management app.
Show the main features: smart scheduling, team collaboration, and AI suggestions.
Use modern, clean aesthetic with the brand colors (orange #FF6B35, dark background).
Include upbeat background music and subtle sound effects for transitions.
Target platform: YouTube and Twitter.

Structured Brief

## Video Brief

**Product:** Vello - AI Task Management
**Duration:** 30 seconds
**Style:** Modern, clean, tech-forward
**Brand Colors:**
  - Primary: #FF6B35 (Orange)
  - Background: #0A0A0A (Dark)
  - Accent: #4ECDC4 (Teal)

**Key Messages:**
1. Smart AI scheduling
2. Team collaboration
3. Instant AI suggestions

**Scenes:**
1. Logo intro (5s)
2. Feature showcase (15s)
3. Social proof (5s)
4. CTA (5s)

**Audio:**
- Background: Upbeat electronic
- SFX: Subtle whooshes, clicks

**Target Platforms:** YouTube, Twitter

Output Format

PIPELINE_COMPLETE.md

# Pipeline Complete: [Video Name]

## Execution Summary

| Step | Skill | Output | Status |
|------|-------|--------|--------|
| 1 | motion-designer | VIDEO_SPEC.md | ✅ |
| 2 | remotion-scaffold | SCAFFOLD_MANIFEST.md | ✅ |
| 3 | remotion-animation | ANIMATION_CONFIG.md | ✅ |
| 4 | remotion-composition | COMPOSITION_STRUCTURE.md | ✅ |
| 5 | remotion-component-gen | SCENE_*_COMPONENT.md | ✅ |
| 6 | remotion-render-config | RENDER_CONFIG.md | ✅ |
| 7 | remotion-asset-coordinator | ASSET_MANIFEST.md | ✅ |

## Generated Files

### Pipeline Artifacts

.remotion-pipeline/20240123_143052/ ├── VIDEO_SPEC.md ├── SCAFFOLD_MANIFEST.md ├── ANIMATION_CONFIG.md ├── COMPOSITION_STRUCTURE.md ├── SCENE_1_COMPONENT.md ├── SCENE_2_COMPONENT.md ├── SCENE_3_COMPONENT.md ├── SCENE_4_COMPONENT.md ├── RENDER_CONFIG.md ├── ASSET_MANIFEST.md └── PIPELINE_COMPLETE.md

### Project Files Created

src/remotion/compositions/VideoName/ ├── index.tsx ✅ Main composition ├── constants.ts ✅ Colors, springs, timing ├── types.ts ✅ TypeScript interfaces └── scenes/ ├── Scene1Intro.tsx ✅ Implemented ├── Scene2Features.tsx ✅ Implemented ├── Scene3Proof.tsx ✅ Implemented └── Scene4CTA.tsx ✅ Implemented

public/ ├── images/ 📁 Ready for assets ├── audio/ │ ├── music/ 📁 Ready for music │ └── sfx/ 📁 Ready for sound effects └── fonts/ 📁 Ready for fonts

## Quick Start

Preview the video

npm run dev

Open Remotion Studio

Navigate to http://localhost:3000

Render final video

npx remotion render src/index.tsx VideoName output.mp4

## Next Steps

### Required Actions
1. [ ] Add background music to `public/audio/music/`
2. [ ] Add sound effects to `public/audio/sfx/`
3. [ ] Add product images to `public/images/`
4. [ ] Review and customize colors in `constants.ts`

### Optional Enhancements
- Run `/remotion-video-reviewer` for QA check
- Run `/remotion-performance-optimizer` for render optimization

## Render Commands

From RENDER_CONFIG.md:

YouTube (1080p, high quality)

npx remotion render src/index.tsx VideoName youtube-output.mp4 \ --codec h264 --crf 18

Twitter (optimized file size)

npx remotion render src/index.tsx VideoName twitter-output.mp4 \ --codec h264 --crf 23

Preview frames

npx remotion still src/index.tsx VideoName preview.png --frame=150

## Pipeline Timing

- Total execution time: ~3-5 minutes
- Motion design: ~45s
- Scaffold: ~15s
- Animation config: ~20s
- Composition: ~15s
- Scene components: ~30s per scene
- Render config: ~10s
- Asset manifest: ~20s

Execution Instructions

When this skill is invoked:

1. Parse the creative brief from the user's input 2. Create pipeline directory with timestamp 3. Execute each step sequentially using claude -p for skill invocation 4. Validate output after each step before proceeding 5. Handle errors gracefully - if a step fails, report and offer to retry 6. Assemble final summary with all artifacts and next steps

Error Handling

If any step fails:

# Retry pattern
MAX_RETRIES=2
RETRY_COUNT=0

while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
  # Attempt skill invocation
  if claude -p "..." --allowedTools "..."; then
    break
  fi
  RETRY_COUNT=$((RETRY_COUNT + 1))
  echo "Retry $RETRY_COUNT of $MAX_RETRIES"
done

if [ $RETRY_COUNT -eq $MAX_RETRIES ]; then
  echo "Step failed after $MAX_RETRIES retries"
  # Log error and continue with partial output
fi

Integration Notes

This skill coordinates these sub-skills:

Each claude -p invocation includes:

• The skill context/instructions
• Relevant output from previous steps
• Specific output file path
• Allowed tools for that step

Example Usage

# Invoke with natural language brief
/create-video-start Create a 30-second demo video for our AI task app Vello

# Invoke with detailed brief
/create-video-start <<EOF
Product: Vello AI Task Manager
Duration: 45 seconds
Style: Modern tech, dark theme
Scenes: Intro, Features (3), Testimonial, CTA
Brand: Orange #FF6B35, Dark #0A0A0A
Target: YouTube, LinkedIn
EOF

Skill Dependencies

Requires these skills to be installed:

• /motion-designer - Video specification creation
• /remotion-scaffold - Project structure setup
• /remotion-animation - Animation configuration
• /remotion-composition - Sequence layout
• /remotion-component-gen - Scene component generation
• /remotion-render-config - Render settings
• /remotion-asset-coordinator - Asset preparation

---

This orchestrator eliminates the manual handoff between skills, creating a complete video project from a single creative brief.

Create Video Start Rules

Sections

Pipeline Execution

Rules for orchestrating the skill pipeline.

• pipeline-order.md — Execution order, dependencies, validation gates
• error-handling.md — Retry logic, failure recovery, cleanup strategies

Skill Invocation

Rules for invoking sub-skills via Claude CLI.

• claude-cli-patterns.md — claude -p patterns, tool permissions, HEREDOC usage
• context-passing.md — Document flow, extraction patterns, format contracts

Quick Reference

Claude CLI Patterns

Basic Invocation Pattern

claude -p "<prompt>" --allowedTools "<tools>"

Parameters

Tool Permission Sets by Skill

Each skill requires specific tools:

# motion-designer: Creates VIDEO_SPEC.md
TOOLS_MOTION="Read,Write,Edit,Bash"

# remotion-scaffold: Creates folder structure
TOOLS_SCAFFOLD="Read,Write,Edit,Bash,Glob"

# remotion-animation: Generates animation configs
TOOLS_ANIMATION="Read,Write,Edit"

# remotion-composition: Creates sequence layout
TOOLS_COMPOSITION="Read,Write,Edit"

# remotion-component-gen: Generates scene components
TOOLS_COMPONENT="Read,Write,Edit,Glob"

# remotion-render-config: Creates render settings
TOOLS_RENDER="Read,Write,Edit"

# remotion-asset-coordinator: Asset manifest
TOOLS_ASSET="Read,Write,Edit,WebSearch"

Prompt Construction Pattern

Template Structure

build_prompt() {
  local SKILL="$1"
  local CONTEXT="$2"
  local OUTPUT_PATH="$3"

  cat << EOF
You are using the /$SKILL skill.

$CONTEXT

Output your result to: $OUTPUT_PATH

Follow the skill's output format exactly.
EOF
}

Context Injection

Include relevant outputs from previous steps:

# Include VIDEO_SPEC in downstream prompts
SPEC_CONTENT=$(cat "$PIPELINE_DIR/VIDEO_SPEC.md")

PROMPT=$(cat << EOF
You are using the /remotion-scaffold skill.

Based on this VIDEO_SPEC.md:
$SPEC_CONTENT

Create the project scaffold...
EOF
)

Multi-Context Injection

When a skill needs multiple inputs:

# remotion-component-gen needs multiple contexts
SPEC=$(cat "$PIPELINE_DIR/VIDEO_SPEC.md")
ANIMATION=$(cat "$PIPELINE_DIR/ANIMATION_CONFIG.md")
COMPOSITION=$(cat "$PIPELINE_DIR/COMPOSITION_STRUCTURE.md")

PROMPT=$(cat << EOF
You are using the /remotion-component-gen skill.

VIDEO_SPEC.md:
$SPEC

ANIMATION_CONFIG.md:
$ANIMATION

COMPOSITION_STRUCTURE.md:
$COMPOSITION

Generate Scene$SCENE_NUM component...
EOF
)

Output Capture Patterns

Capture to File

# Direct file output (skill writes the file)
claude -p "$PROMPT" --allowedTools "$TOOLS"

# Capture stdout to file
claude -p "$PROMPT" --allowedTools "$TOOLS" > "$OUTPUT_FILE"

Capture with Validation

OUTPUT=$(claude -p "$PROMPT" --allowedTools "$TOOLS" 2>&1)
EXIT_CODE=$?

if [ $EXIT_CODE -eq 0 ]; then
  echo "Skill completed successfully"
else
  echo "Skill failed with exit code: $EXIT_CODE"
  echo "Output: $OUTPUT"
fi

HEREDOC Patterns

Simple HEREDOC

claude -p "$(cat << 'EOF'
You are using the /motion-designer skill.

Create a VIDEO_SPEC.md for:
- Product demo video
- 30 seconds
- Modern tech aesthetic

EOF
)" --allowedTools "Read,Write,Edit"

HEREDOC with Variable Interpolation

# Note: No quotes around EOF allows variable expansion
claude -p "$(cat << EOF
You are using the /remotion-scaffold skill.

Based on this spec:
$VIDEO_SPEC_CONTENT

Create scaffold at: $PROJECT_PATH
EOF
)" --allowedTools "Read,Write,Edit,Bash"

HEREDOC with Preserved Formatting

# Use 'EOF' (quoted) to prevent variable expansion
claude -p "$(cat << 'EOF'
Generate this exact TypeScript:

const springConfig = { mass: 1, damping: 10, stiffness: 100 };

EOF
)" --allowedTools "Write"

Parallel Execution

# Run independent skills in parallel
claude -p "$ANIMATION_PROMPT" --allowedTools "$TOOLS_ANIMATION" &
PID1=$!

claude -p "$COMPOSITION_PROMPT" --allowedTools "$TOOLS_COMPOSITION" &
PID2=$!

# Wait for both to complete
wait $PID1
STATUS1=$?

wait $PID2
STATUS2=$?

if [ $STATUS1 -eq 0 ] && [ $STATUS2 -eq 0 ]; then
  echo "Parallel execution successful"
fi

Loop Patterns

Scene Generation Loop

# Extract scene count from VIDEO_SPEC
SCENE_COUNT=$(grep -c "^## Scene" "$PIPELINE_DIR/VIDEO_SPEC.md")

for i in $(seq 1 $SCENE_COUNT); do
  PROMPT=$(build_scene_prompt $i)

  claude -p "$PROMPT" \
    --allowedTools "$TOOLS_COMPONENT"

  # Validate output
  if [ ! -f "$PIPELINE_DIR/SCENE_${i}_COMPONENT.md" ]; then
    echo "ERROR: Scene $i generation failed"
  fi
done

Environment Variables

# Set environment for all invocations
export ANTHROPIC_API_KEY="${ANTHROPIC_API_KEY}"
export PIPELINE_DIR="$PIPELINE_DIR"

# Pass environment context
claude -p "Working directory: $PIPELINE_DIR
$PROMPT" --allowedTools "$TOOLS"

Context Passing Rules

Document Flow

Each skill produces a document that downstream skills consume:

Creative Brief (user input)
      │
      ▼
┌─────────────────────────┐
│ VIDEO_SPEC.md           │ ◄── motion-designer output
│ - Overview              │
│ - Color Palette         │
│ - Scene Definitions     │
│ - Audio Specs           │
└─────────────────────────┘
      │
      ├──────────────────┬──────────────────┬──────────────────┐
      ▼                  ▼                  ▼                  ▼
┌─────────────┐   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐
│ SCAFFOLD_   │   │ ANIMATION_  │   │ COMPOSITION_│   │ RENDER_     │
│ MANIFEST.md │   │ CONFIG.md   │   │ STRUCTURE.md│   │ CONFIG.md   │
└─────────────┘   └─────────────┘   └─────────────┘   └─────────────┘
      │                  │                  │
      │                  └────────┬─────────┘
      │                           ▼
      │                  ┌─────────────────────────┐
      │                  │ SCENE_*_COMPONENT.md    │
      │                  │ (one per scene)         │
      │                  └─────────────────────────┘
      │                           │
      └───────────┬───────────────┘
                  ▼
         ┌─────────────────────────┐
         │ ASSET_MANIFEST.md       │
         └─────────────────────────┘
                  │
                  ▼
         ┌─────────────────────────┐
         │ PIPELINE_COMPLETE.md    │
         └─────────────────────────┘

Context Extraction Patterns

Extract Specific Sections

# Extract just the color palette from VIDEO_SPEC
extract_palette() {
  sed -n '/## Color Palette/,/^## /p' "$PIPELINE_DIR/VIDEO_SPEC.md" | head -n -1
}

# Extract scene definitions
extract_scenes() {
  sed -n '/## Scenes/,/^## /p' "$PIPELINE_DIR/VIDEO_SPEC.md" | head -n -1
}

Extract Scene-Specific Context

# Get details for Scene N
extract_scene_details() {
  local SCENE_NUM=$1
  sed -n "/### Scene $SCENE_NUM/,/^### Scene/p" "$PIPELINE_DIR/VIDEO_SPEC.md" | head -n -1
}

Context Size Management

Truncation for Large Specs

# If VIDEO_SPEC is too large, extract only relevant parts
MAX_CONTEXT_LINES=200

if [ $(wc -l < "$PIPELINE_DIR/VIDEO_SPEC.md") -gt $MAX_CONTEXT_LINES ]; then
  # Use overview + specific scene only
  CONTEXT=$(cat << EOF
$(head -50 "$PIPELINE_DIR/VIDEO_SPEC.md")

...

$(extract_scene_details $SCENE_NUM)
EOF
  )
else
  CONTEXT=$(cat "$PIPELINE_DIR/VIDEO_SPEC.md")
fi

Summary Context

For downstream skills that need overview only:

# Create a summary context
create_summary_context() {
  cat << EOF
## Video Overview
$(grep -A5 "## Overview" "$PIPELINE_DIR/VIDEO_SPEC.md")

## Scene Count: $(grep -c "^### Scene" "$PIPELINE_DIR/VIDEO_SPEC.md")

## Duration: $(grep "Duration:" "$PIPELINE_DIR/VIDEO_SPEC.md" | head -1)
EOF
}

Document Format Contracts

VIDEO_SPEC.md Contract

Skills that consume VIDEO_SPEC.md expect:

## Overview
- Duration: X seconds
- FPS: X
- Dimensions: WxH

## Color Palette
- Primary: #XXXXXX
- Secondary: #XXXXXX
- Background: #XXXXXX

## Scenes

### Scene 1: [Name]
- Duration: X seconds
- Start: Xs
- End: Xs
- Elements: [list]
- Animation: [description]

## Audio
- Music: [description]
- SFX: [list]

ANIMATION_CONFIG.md Contract

Skills that consume ANIMATION_CONFIG.md expect:

## Spring Configurations

### Default Spring

const defaultSpring = { mass: 1, damping: 10, stiffness: 100 };

### [Animation Name] Spring

const [name]Spring = {...};

## Timing Constants

const TIMING = { FADE_IN: 15, FADE_OUT: 15, STAGGER_DELAY: 5 };

COMPOSITION_STRUCTURE.md Contract

Skills that consume COMPOSITION_STRUCTURE.md expect:

## Sequence Layout

<Sequence from={0} durationInFrames={X}> <Scene1 /> </Sequence> <Sequence from={X} durationInFrames={Y}> <Scene2 /> </Sequence>

## Scene Timing

| Scene | Start Frame | End Frame | Duration |
|-------|-------------|-----------|----------|
| 1     | 0           | X         | X frames |
| 2     | X           | Y         | Y frames |

## Total Duration
X frames = Y seconds @ Z fps

Context Validation

Before passing context, validate it contains required data:

validate_video_spec() {
  local SPEC="$1"
  local ERRORS=""

  if ! grep -q "## Overview" "$SPEC"; then
    ERRORS+="Missing Overview section\n"
  fi

  if ! grep -q "## Color Palette" "$SPEC"; then
    ERRORS+="Missing Color Palette section\n"
  fi

  if ! grep -q "### Scene" "$SPEC"; then
    ERRORS+="Missing Scene definitions\n"
  fi

  if [ -n "$ERRORS" ]; then
    echo "VIDEO_SPEC validation failed:"
    echo -e "$ERRORS"
    return 1
  fi
  return 0
}

Inter-Skill References

When a skill needs to reference output from another skill:

# In component-gen prompt, reference animation config
PROMPT=$(cat << EOF
Using these spring configurations from ANIMATION_CONFIG.md:
$(grep -A10 "### Default Spring" "$PIPELINE_DIR/ANIMATION_CONFIG.md")

And these timing constants:
$(grep -A10 "## Timing Constants" "$PIPELINE_DIR/ANIMATION_CONFIG.md")

Generate Scene$SCENE_NUM with these animations applied.
EOF
)

Context Caching

For repeated access, cache extracted context:

# Cache commonly used extracts
CACHE_DIR="$PIPELINE_DIR/.cache"
mkdir -p "$CACHE_DIR"

get_color_palette() {
  if [ ! -f "$CACHE_DIR/palette.txt" ]; then
    extract_palette > "$CACHE_DIR/palette.txt"
  fi
  cat "$CACHE_DIR/palette.txt"
}

Error Handling Rules

Retry Logic

Each skill invocation should follow this retry pattern:

invoke_skill() {
  local SKILL_NAME="$1"
  local PROMPT="$2"
  local TOOLS="$3"
  local MAX_RETRIES=2
  local RETRY_COUNT=0
  local SUCCESS=false

  while [ $RETRY_COUNT -lt $MAX_RETRIES ] && [ "$SUCCESS" = false ]; do
    echo "Invoking $SKILL_NAME (attempt $((RETRY_COUNT + 1))/$MAX_RETRIES)..."

    if claude -p "$PROMPT" --allowedTools "$TOOLS" 2>&1; then
      SUCCESS=true
    else
      RETRY_COUNT=$((RETRY_COUNT + 1))
      if [ $RETRY_COUNT -lt $MAX_RETRIES ]; then
        echo "Retry $RETRY_COUNT: $SKILL_NAME failed, retrying..."
        sleep 2
      fi
    fi
  done

  if [ "$SUCCESS" = false ]; then
    echo "ERROR: $SKILL_NAME failed after $MAX_RETRIES attempts"
    return 1
  fi
  return 0
}

Failure Recovery Strategies

Strategy 1: Partial Output Continuation

If a skill partially succeeds (creates some output but not all), continue with available output:

# Example: component-gen creates 3 of 4 scenes
if [ $(ls $PIPELINE_DIR/SCENE_*_COMPONENT.md | wc -l) -gt 0 ]; then
  echo "Partial success: $(ls $PIPELINE_DIR/SCENE_*_COMPONENT.md | wc -l) scenes created"
  echo "Missing scenes logged for manual completion"
  # Continue pipeline with partial output
fi

Strategy 2: Fallback to Manual Prompt

If automated invocation fails, provide manual instructions:

if ! invoke_skill "remotion-animation" "$PROMPT" "$TOOLS"; then
  echo "=== MANUAL FALLBACK REQUIRED ==="
  echo "Run this command manually:"
  echo "claude -p \"$PROMPT\" --allowedTools \"$TOOLS\""
  echo "Then place output at: $PIPELINE_DIR/ANIMATION_CONFIG.md"
  echo "================================"
fi

Strategy 3: Skip Non-Critical Steps

Some steps are optional and can be skipped:

# Skip pattern for non-critical steps
if ! invoke_skill "remotion-render-config" "$PROMPT" "$TOOLS"; then
  echo "WARN: Skipping render-config, using defaults"
  cat > "$PIPELINE_DIR/RENDER_CONFIG.md" << 'EOF'
# Default Render Config
- Codec: h264
- CRF: 18
- Resolution: 1920x1080
- FPS: 30
EOF
fi

Error Logging

All errors should be logged to a pipeline error file:

LOG_FILE="$PIPELINE_DIR/pipeline.log"
ERROR_FILE="$PIPELINE_DIR/errors.log"

log() {
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

log_error() {
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1" | tee -a "$ERROR_FILE"
}

Pipeline Status File

Maintain a status file for pipeline progress:

STATUS_FILE="$PIPELINE_DIR/status.json"

update_status() {
  local STEP="$1"
  local STATUS="$2"  # pending, running, success, failed, skipped

  # Update JSON status file
  jq --arg step "$STEP" --arg status "$STATUS" \
    '.steps[$step] = $status' "$STATUS_FILE" > tmp.json && mv tmp.json "$STATUS_FILE"
}

# Initialize status file
cat > "$STATUS_FILE" << 'EOF'
{
  "started": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "steps": {
    "motion-designer": "pending",
    "remotion-scaffold": "pending",
    "remotion-animation": "pending",
    "remotion-composition": "pending",
    "remotion-component-gen": "pending",
    "remotion-render-config": "pending",
    "remotion-asset-coordinator": "pending"
  }
}
EOF

Cleanup on Failure

If the pipeline fails catastrophically, offer cleanup:

cleanup_failed_pipeline() {
  echo "Pipeline failed. Clean up artifacts? (y/n)"
  read -r RESPONSE
  if [ "$RESPONSE" = "y" ]; then
    rm -rf "$PIPELINE_DIR"
    echo "Artifacts cleaned up"
  else
    echo "Artifacts preserved at: $PIPELINE_DIR"
  fi
}

trap cleanup_failed_pipeline ERR

Pipeline Order Rules

Execution Order and Dependencies

The pipeline MUST execute in this exact order due to data dependencies:

motion-designer (1)
       ↓
       VIDEO_SPEC.md
       ↓
remotion-scaffold (2)
       ↓
       SCAFFOLD_MANIFEST.md
       ↓
remotion-animation (3) ←──┐
       ↓                  │
       ANIMATION_CONFIG.md│
       ↓                  │
remotion-composition (4)  │
       ↓                  │
       COMPOSITION_STRUCTURE.md
       ↓                  │
remotion-component-gen (5)┘ (uses both ANIMATION_CONFIG + COMPOSITION_STRUCTURE)
       ↓
       SCENE_*_COMPONENT.md
       ↓
remotion-render-config (6)
       ↓
       RENDER_CONFIG.md
       ↓
remotion-asset-coordinator (7)
       ↓
       ASSET_MANIFEST.md

Dependency Matrix

Parallel Execution Opportunities

Steps 3 and 4 (animation + composition) can run in parallel since they both only depend on VIDEO_SPEC.md:

# Parallel execution pattern
claude -p "remotion-animation..." &
PID_ANIMATION=$!

claude -p "remotion-composition..." &
PID_COMPOSITION=$!

wait $PID_ANIMATION $PID_COMPOSITION

Validation Gates

Before proceeding to the next step, validate:

1. After motion-designer: VIDEO_SPEC.md exists and contains:

• Overview section with duration, fps, dimensions
• Color palette with hex codes
• At least one scene definition
• Audio specifications

2. After remotion-scaffold:

• Composition directory exists
• index.tsx created
• constants.ts created
• scenes/ directory exists

3. After remotion-animation:

• ANIMATION_CONFIG.md contains spring configs
• At least one spring configuration defined
• Interpolation patterns documented

4. After remotion-composition:

• COMPOSITION_STRUCTURE.md contains Sequence definitions
• Total duration calculated
• Scene timing breakdown present

5. After remotion-component-gen:

• One SCENE_*_COMPONENT.md per scene in spec
• Corresponding .tsx file in scenes/ folder
• Imports reference constants.ts

6. After remotion-render-config:

• RENDER_CONFIG.md contains codec settings
• Platform-specific commands included

7. After remotion-asset-coordinator:

• ASSET_MANIFEST.md lists all required assets
• Source recommendations provided