name: remotion-scaffold
description: Scaffolds Remotion project folder structure, base configuration files, and file organization. Focuses ONLY on directory creation, empty file templates, and Remotion configuration. Use when starting a new video project or when asked to "scaffold Remotion project", "create project structure", "setup Remotion folders".

Remotion Scaffold

Creates the foundational folder structure, configuration files, and organizational framework for Remotion video projects. This skill focuses exclusively on project setup and does NOT generate animation logic or component implementation.

What This Skill Does

Generates project scaffolding for:

1. Directory structure — Organized folder layout for compositions, scenes, assets
2. Configuration files — Base constants.ts, types.ts with empty templates
3. Empty scene templates — Placeholder scene components with TODO markers
4. Asset directories — Organized folders for images, audio, fonts
5. Registration setup — Composition registration in Root.tsx

Scope Boundaries

IN SCOPE:
- Creating folder structure
- Writing empty file templates
- Setting up configuration skeleton
- Directory organization patterns

OUT OF SCOPE:
- Animation implementation (use /remotion-animation)
- Scene component logic (use /remotion-component-gen)
- Sequence composition (use /remotion-composition)
- Component generation (use /remotion-component-gen)

Input/Output Formats

Input Format: Project Requirements

Accepts project setup requirements:

Natural Language:

Create a new Remotion project scaffold for a 30-second video with 4 scenes.

Structured Format:

## Project Requirements

**Project Name:** ProductDemo
**Duration:** 30 seconds
**Frame Rate:** 30 fps
**Dimensions:** 1920x1080 (16:9)
**Number of Scenes:** 4 (Intro, Features, Demo, CTA)
**Asset Types:** Images, Audio (music + SFX)

Output Format: SCAFFOLD_MANIFEST.md

Generates a manifest documenting created structure:

# Scaffold Manifest: ProductDemo

## Status
✅ Directory structure created
✅ Configuration files generated
✅ Scene templates created (empty)
⏳ Ready for implementation

## Generated Structure

src/remotion/compositions/ProductDemo/
├── index.tsx # ✅ Created - Main composition (empty)
├── constants.ts # ✅ Created - Constants template
├── types.ts # ✅ Created - Type definitions
└── scenes/
├── Scene1Intro.tsx # ✅ Created - Empty template
├── Scene2Features.tsx # ✅ Created - Empty template
├── Scene3Demo.tsx # ✅ Created - Empty template
└── Scene4CTA.tsx # ✅ Created - Empty template

public/
├── images/ # ✅ Created - Empty directory
├── audio/
│ ├── music/ # ✅ Created - Empty directory
│ └── sfx/ # ✅ Created - Empty directory
└── fonts/ # ✅ Created - Empty directory

## File Templates Created

### Main Composition: `index.tsx`
```typescript
import { AbsoluteFill, Sequence } from "remotion";
import { SCENE_TIMING } from "./constants";
import { Scene1Intro } from "./scenes/Scene1Intro";
import { Scene2Features } from "./scenes/Scene2Features";
import { Scene3Demo } from "./scenes/Scene3Demo";
import { Scene4CTA } from "./scenes/Scene4CTA";
import type { ProductDemoProps } from "./types";

export function ProductDemo({}: ProductDemoProps) {
  return (
    <AbsoluteFill>
      {/* TODO: Add composition layout via /remotion-composition */}
      <Sequence
        from={SCENE_TIMING.intro.start}
        durationInFrames={SCENE_TIMING.intro.duration}
      >
        <Scene1Intro />
      </Sequence>

      {/* Additional scenes... */}
    </AbsoluteFill>
  );
}

Constants: constants.ts

// TODO: Define color palette
export const COLORS = {
  // Add colors here
} as const;

// TODO: Configure spring animations via /remotion-animation
export const SPRING_CONFIGS = {
  // Add spring configs here
} as const;

// Scene timing (30fps, 30 seconds total = 900 frames)
const FPS = 30;

export const SCENE_TIMING = {
  intro: { start: 0, duration: 5 * FPS },
  features: { start: 5 * FPS, duration: 10 * FPS },
  demo: { start: 15 * FPS, duration: 10 * FPS },
  cta: { start: 25 * FPS, duration: 5 * FPS },
} as const;

Types: types.ts

export interface ProductDemoProps {
  // Add custom props here
}

export interface SceneProps {
  // Common scene props
}

Scene Template: scenes/Scene1Intro.tsx

import { AbsoluteFill } from "remotion";

export function Scene1Intro() {
  return (
    <AbsoluteFill>
      {/* TODO: Implement scene via /remotion-component-gen */}
    </AbsoluteFill>
  );
}

Next Steps

1. Define animations → Run /remotion-animation to generate animation configs
2. Build composition → Run /remotion-composition to structure Sequence layout
3. Implement scenes → Run /remotion-component-gen for each scene
4. Configure render → Run /remotion-render-config for output settings
5. Add assets → Run /remotion-asset-coordinator for asset preparation

Configuration Summary

File Locations

All files created in:
- Composition: /path/to/project/src/remotion/compositions/ProductDemo/
- Assets: /path/to/project/public/

Scaffold Checklist

Creation checklist:
- [x] Create composition folder structure
- [x] Generate main composition file (index.tsx) with TODO markers
- [x] Generate constants file (constants.ts) as template
- [x] Generate types file (types.ts)
- [x] Create empty scene component files
- [x] Create asset directories (public/images/, public/audio/)
- [x] Add composition registration skeleton
- [ ] Animation implementation (next: /remotion-animation)
- [ ] Composition logic (next: /remotion-composition)
- [ ] Scene implementation (next: /remotion-component-gen)

## Directory Structure Patterns

### Pattern 1: Simple Project (1-2 scenes)

src/remotion/compositions/VideoName/
├── index.tsx # Main composition
├── constants.ts # Configuration constants
└── types.ts # TypeScript types

### Pattern 2: Multi-Scene Project (3+ scenes)

src/remotion/compositions/VideoName/
├── index.tsx # Main composition
├── constants.ts # Shared constants
├── types.ts # Type definitions
└── scenes/
├── Scene1.tsx
├── Scene2.tsx
└── Scene3.tsx

### Pattern 3: Complex Project (with audio)

src/remotion/compositions/VideoName/
├── index.tsx # Main composition
├── constants.ts # Configuration
├── types.ts # Types
├── audio.ts # Audio configuration
└── scenes/
└── ...

### Pattern 4: Component Library Project

src/remotion/
├── components/
│ ├── particles/
│ ├── text/
│ ├── progress/
│ └── transitions/
├── compositions/
│ └── VideoName/
└── utils/
├── seededRandom.ts
└── timing.ts

## File Templates

### Empty Main Composition

```typescript
import { AbsoluteFill } from "remotion";
import type { VideoNameProps } from "./types";

export function VideoName({}: VideoNameProps) {
  return (
    <AbsoluteFill>
      {/* TODO: Add composition structure via /remotion-composition */}
    </AbsoluteFill>
  );
}

Empty Constants Template

// TODO: Define via /remotion-animation
export const COLORS = {} as const;
export const SPRING_CONFIGS = {} as const;
export const SCENE_TIMING = {} as const;

Empty Types Template

export interface VideoNameProps {
  // Add props here
}

Empty Scene Template

import { AbsoluteFill } from "remotion";

export function Scene1() {
  return (
    <AbsoluteFill>
      {/* TODO: Implement via /remotion-component-gen */}
    </AbsoluteFill>
  );
}

Registration Template

Add to src/remotion/Root.tsx:

import { Composition } from "remotion";
import { VideoName } from "./compositions/VideoName";

// Add to RemotionRoot component:
<Composition
  id="VideoName"
  component={VideoName}
  durationInFrames={900}  // TODO: Calculate based on requirements
  fps={30}
  width={1920}
  height={1080}
  defaultProps={{}}
/>

Video Format Presets

Quick reference for common video formats:

// YouTube (16:9)
{ width: 1920, height: 1080, fps: 30 }

// Instagram Reels / TikTok (9:16)
{ width: 1080, height: 1920, fps: 30 }

// Twitter/X (16:9)
{ width: 1920, height: 1080, fps: 30 }

// Square (1:1)
{ width: 1080, height: 1080, fps: 30 }

Asset Directory Organization

Standard asset directory structure:

public/
├── images/
│   ├── logos/
│   ├── backgrounds/
│   └── icons/
├── audio/
│   ├── music/
│   └── sfx/
└── fonts/
    └── [custom-fonts].woff2

Scaffold Workflow

1. Parse requirements → Extract project name, duration, scenes, format
2. Create directories → Generate folder structure
3. Write empty templates → Create files with TODO markers
4. Setup registration → Add composition to Root.tsx
5. Generate manifest → Document created structure in SCAFFOLD_MANIFEST.md
6. Hand off → Direct to specialized skills for implementation

Integration with Other Skills

This skill is the FIRST STEP in the pipeline:

remotion-scaffold (this skill)
    ↓ outputs: SCAFFOLD_MANIFEST.md
remotion-animation
    ↓ outputs: ANIMATION_CONFIG.md
remotion-composition
    ↓ outputs: COMPOSITION_STRUCTURE.md
remotion-component-gen (per scene)
    ↓ outputs: SCENE_COMPONENT.md
remotion-render-config
    ↓ outputs: RENDER_CONFIG.md

Works with:
- /motion-designer — Project requirements may come from design specs
- /remotion-animation — Next step for animation configuration
- /remotion-composition — Next step for composition structure
- /remotion-component-gen — Next step for scene implementation
- /remotion-render-config — Final step for render settings

This skill provides clean, minimal project scaffolding that serves as the foundation for the Remotion implementation pipeline.