Remotion Video Reviewer

Remotion Video Reviewer

Provides comprehensive, structured reviews of Remotion video implementations against motion design specifications. Identifies issues, assesses impact, and generates actionable revision lists.

What This Skill Does

Performs multi-layer review analysis:

1. Spec compliance — Verifies implementation matches design spec
2. Code quality — Checks patterns, performance, best practices
3. Timing accuracy — Validates frame calculations and animation timing
4. Visual fidelity — Confirms colors, typography, layout match spec
5. Asset quality — Verifies assets are production-ready
6. Performance — Identifies render bottlenecks

Input/Output Formats

Input Format: VIDEO_SPEC.md + Code Files

Requires both the original specification and implemented code:

VIDEO_SPEC.md (from /motion-designer)

# Video Title

## Overview
- Duration: 30 seconds
- Frame Rate: 30 fps

## Color Palette
Primary: #FF6B35
Background: #0A0A0A

## Scene 1: Opening (0s - 5s)
- Logo scales from 0.8 to 1.0
- Spring config: { damping: 200 }

Code Files to review:

• src/remotion/compositions/VideoName/index.tsx
• src/remotion/compositions/VideoName/constants.ts
• src/remotion/compositions/VideoName/types.ts
• Asset files in public/

Output Format: REVIEW_REPORT.md

Generates a comprehensive review with prioritized issues:

# Video Review Report: [Video Title]

**Date:** 2026-01-23
**Reviewer:** remotion-video-reviewer
**Spec Version:** VIDEO_SPEC.md v1.0
**Code Location:** `src/remotion/compositions/VideoName/`

---

## Executive Summary

**Overall Status:** ✅ APPROVED WITH MINOR REVISIONS

**Quick Stats:**
- Total Issues: 4 (0 critical, 1 high, 2 medium, 1 low)
- Spec Compliance: 95%
- Code Quality: Excellent
- Production Ready: Yes, after addressing HIGH priority items

**Recommendation:** Address high-priority color mismatch before final render. Medium and low priority items are optional improvements.

---

## Compliance Scores

| Category | Score | Status | Notes |
|----------|-------|--------|-------|
| **Spec Compliance** | 95% | 🟢 Pass | 1 color mismatch in Scene 3 |
| **Code Quality** | 98% | 🟢 Pass | Excellent structure, minor optimization opportunity |
| **Timing Accuracy** | 100% | 🟢 Pass | All frame calculations correct |
| **Visual Fidelity** | 95% | 🟢 Pass | Minor color deviation |
| **Asset Quality** | 90% | 🟡 Good | 1 image could be optimized |
| **Performance** | 95% | 🟢 Pass | Excellent render times |

**Overall Compliance:** 95.5% — Production Ready

---

## Issues Found

### CRITICAL (Must Fix Before Production)
_None_ ✅

### HIGH Priority (Should Fix)

#### 1. Scene 3 Background Color Mismatch
**Category:** Visual Fidelity
**Location:** `src/remotion/compositions/VideoName/scenes/Scene3.tsx:15`
**Impact:** Visual inconsistency with brand colors

**Issue:**
```typescript
// Current implementation
backgroundColor: '#0B0B0B'  // ❌ Wrong

// Spec requirement
Primary: #FF6B35
Background: #0A0A0A  // ✅ Correct

Fix:

// Update to use COLORS constant
backgroundColor: COLORS.background  // Now: #0A0A0A

Verification:

• Update constants.ts if COLORS.background is incorrect
• Verify Scene 3 uses COLORS.background
• Visual check against spec color palette

MEDIUM Priority (Consider Fixing)

2. Large Product Image Could Be Optimized

Category: Asset Quality Location: public/images/product.png Impact: Slower render times, larger output file

Current:

• Format: PNG
• Resolution: 4000x3000
• File size: 8.2MB

Recommendation:

• Format: JPEG (no transparency needed)
• Resolution: 1920x1440 (2x display size)
• Quality: 90%
• Expected size: ~400KB (95% reduction)

Fix:

# Resize and convert
magick public/images/product.png -resize 1920x1440 -quality 90 public/images/product.jpg

# Update code to use .jpg
<Img src={staticFile('images/product.jpg')} />

Benefits:

• Faster preview/render times
• Smaller final video file
• No visual quality loss

3. Particle System Could Use Memoization

Category: Performance Location: src/remotion/compositions/VideoName/scenes/Scene2.tsx:45 Impact: Minor performance improvement possible

Current:

// Particle positions recalculated (deterministic but not cached)
const particles = Array.from({ length: 70 }, (_, i) => ({
  x: seededRandom(i * 123) * width,
  y: seededRandom(i * 456) * height,
}));

Recommendation:

import { useMemo } from 'react';

const particles = useMemo(
  () => Array.from({ length: 70 }, (_, i) => ({
    x: seededRandom(i * 123) * width,
    y: seededRandom(i * 456) * height,
  })),
  [width, height]
);

Expected Impact: 5-10% faster render for Scene 2

LOW Priority (Nice to Have)

4. Add JSDoc Comments to Scene Components

Category: Code Quality Location: All scene components Impact: Improved maintainability

Recommendation:

/**
 * Scene 1: Opening animation with logo reveal
 * Duration: 0s - 5s (frames 0-150)
 * Spec reference: VIDEO_SPEC.md Section "Scene 1"
 */
function Scene1Opening() {
  // ...
}

Benefits:

• Easier for team members to understand
• Better IDE autocomplete
• Clear spec traceability

Detailed Analysis

Spec Compliance (95%)

✅ Passed:

• All 4 scenes implemented
• Scene timing matches spec exactly (verified frame calculations)
• Typography matches (Inter font, correct weights)
• Audio placement correct (background music + 2 SFX)
• Spring configurations match spec descriptions
• All animations implemented as described

❌ Failed:

• Scene 3 background color (#0B0B0B instead of #0A0A0A)

Verification Steps Completed:

• Compared scene count: 4 scenes (matches)
• Verified scene durations: All correct
• Checked color palette: 1 mismatch found
• Validated spring configs: All match
• Tested audio timing: Correct

Code Quality (98%)

✅ Excellent Patterns:

• Constants properly extracted (COLORS, SPRING_CONFIGS, SCENE_TIMING)
• Consistent naming conventions (Scene1Opening, Scene2Content)
• AbsoluteFill used correctly in all scenes
• Progress variables extracted (not inline spring calls)
• TypeScript types defined for all props
• Clean, readable code structure
• Proper imports from remotion

✅ Best Practices Followed:

• useVideoConfig used for responsive positioning
• staticFile() used for all assets
• Sequence timing uses constants
• No magic numbers in code
• Deterministic random in particle system

🟡 Minor Improvements:

• Could add useMemo to particle calculation (LOW impact)
• JSDoc comments would improve maintainability

Timing Accuracy (100%)

✅ All Verified:

Scene 1: 0s - 5s    → frames 0-150    ✓ Correct (5 * 30fps)
Scene 2: 5s - 15s   → frames 150-450  ✓ Correct (10 * 30fps)
Scene 3: 15s - 25s  → frames 450-750  ✓ Correct (10 * 30fps)
Scene 4: 25s - 30s  → frames 750-900  ✓ Correct (5 * 30fps)

Total: 30s = 900 frames ✓ Correct

Validation:

• All SCENE_TIMING constants match spec
• Sequence components use correct start/duration
• No timing overlap or gaps
• Audio timing matches frame calculations

Asset Quality (90%)

✅ Good:

• Logo: 800x800 PNG, optimized, transparent ✓
• Background music: 30s MP3, 192kbps ✓
• Whoosh SFX: MP3, proper duration ✓
• Pop SFX: MP3, proper duration ✓
• Font: Inter loaded correctly via @remotion/google-fonts ✓

🟡 Could Improve:

• Product image: 8.2MB PNG → Should be 1920x1440 JPEG (~400KB)

Asset Checklist:

• All assets present in public/
• Correct formats used (mostly)
• staticFile() imports correct
• File sizes optimized (1 large image)
• No missing assets

Performance (95%)

Render Performance:

• Average: 85ms/frame ✅ Excellent (target: <100ms)
• Scene 1: 65ms/frame ✅
• Scene 2: 105ms/frame 🟡 (particle system, acceptable)
• Scene 3: 75ms/frame ✅
• Scene 4: 70ms/frame ✅

No Major Issues:

• ✅ Spring calculations extracted and reused
• ✅ No expensive operations in render path
• ✅ Assets load efficiently (except large PNG)
• ✅ No memory leaks detected

Minor Optimization Opportunities:

• Memoize particle calculations (5-10% improvement in Scene 2)
• Optimize product.png (faster asset loading)

Recommendations

Before Production

1. ✅ Fix HIGH priority color mismatch (5 minutes)
2. ⏭️ Consider optimizing product image (10 minutes) - Optional but recommended

For Future Iterations

1. Add JSDoc comments to scene components
2. Apply memoization to particle system
3. Consider extracting ParticleSystem to reusable component

Testing Checklist

Completed validation:

• Visual inspection of all scenes
• Frame-by-frame timing verification
• Color palette comparison
• Audio synchronization test
• Asset loading verification
• Render performance profiling
• Code pattern review
• Best practices compliance

Next Steps

1. Address HIGH priority issue: Fix Scene 3 background color
2. Optional: Optimize product.png asset
3. Final render: Generate production video
4. Performance check: Run /remotion-performance-optimizer if render times increase
5. Archive: Save REVIEW_REPORT.md with project files

Approval

Status: ✅ APPROVED WITH MINOR REVISIONS

This implementation is production-ready after addressing the Scene 3 color mismatch. All critical functionality, timing, and structure are correct. Medium and low priority items are optional improvements that can be addressed in future iterations.

Signed: remotion-video-reviewer Date: 2026-01-23

**This document provides:**
- Executive summary with quick approval status
- Quantified compliance scores (95%, 98%, etc.)
- Prioritized issues (CRITICAL, HIGH, MEDIUM, LOW)
- Specific code locations and fixes
- Detailed analysis per category
- Testing verification checklist
- Clear next steps
- Official approval status

**Feeds into:**
- Developer: Fix identified issues
- `/remotion-performance-optimizer` if performance issues found
- Final production render after approval

## Review Process

### 1. Spec Comparison

Compare implementation against motion design spec:

**Check:**
- [ ] All scenes from spec are implemented
- [ ] Scene durations match spec timing
- [ ] Color palette matches hex codes exactly
- [ ] Typography (font, size, weight) matches
- [ ] Animation descriptions are accurately translated
- [ ] Audio placement matches timing
- [ ] Spring configurations match spec

### 2. Code Quality Review

Evaluate code structure and patterns:

**Check:**
- [ ] Constants extracted (colors, springs, timing)
- [ ] Scene components follow naming convention
- [ ] AbsoluteFill used for all scenes
- [ ] Progress variables extracted (not inline calculations)
- [ ] useVideoConfig used for responsive positioning
- [ ] TypeScript types defined
- [ ] Proper imports from remotion

### 3. Timing Accuracy

Verify frame calculations:

**Check:**
- [ ] Seconds correctly converted to frames (seconds * fps)
- [ ] Scene timing constants are accurate
- [ ] Delay calculations use frame offsets
- [ ] Transitions account for overlap
- [ ] Total duration matches spec
- [ ] Animation hold times are correct

### 4. Animation Review

Assess animation implementation:

**Check:**
- [ ] Spring configs match spec descriptions
- [ ] Interpolate ranges match spec values
- [ ] Easing functions appropriate for motion type
- [ ] Stagger delays calculated correctly
- [ ] Continuous animations use appropriate patterns
- [ ] Exit animations present where specified

### 5. Visual Fidelity

Confirm visual accuracy:

**Check:**
- [ ] Background colors match spec
- [ ] Element colors use COLORS constants
- [ ] Font sizes match spec exactly
- [ ] Positioning follows spec layout
- [ ] Visual hierarchy maintained
- [ ] Layer organization (background/midground/foreground)

### 6. Asset Quality

Validate asset preparation:

**Check:**
- [ ] All required assets present
- [ ] Assets use staticFile() import
- [ ] Image formats appropriate (PNG for transparency, JPEG for photos)
- [ ] Audio files in supported formats
- [ ] Asset dimensions suitable for composition
- [ ] Fonts loaded correctly

### 7. Performance Check

Identify performance issues:

**Check:**
- [ ] No expensive calculations in render
- [ ] Progress variables reused
- [ ] No unnecessary spring recalculations
- [ ] Memoization used where appropriate
- [ ] Large assets optimized
- [ ] No memory leaks in loops

## Review Output Format

### Summary

```markdown
## Review Summary

**Spec Compliance**: 95% (1 minor deviation)
**Code Quality**: Excellent
**Timing Accuracy**: 100%
**Visual Fidelity**: 98% (color mismatch in Scene 3)
**Asset Quality**: Good (1 optimization needed)
**Performance**: Excellent

**Overall Rating**: READY FOR PRODUCTION (with minor revisions)

Issues List (Prioritized)

## Issues Found

### CRITICAL (Must Fix)
None

### HIGH (Should Fix)
1. **Scene 3 background color mismatch**
   - Spec: #0A0A0A
   - Code: #0B0B0B
   - Impact: Visual inconsistency
   - Fix: Update COLORS.background

### MEDIUM (Consider Fixing)
1. **Product image could be optimized**
   - Current: 4000x3000 PNG
   - Recommendation: 1920x1440 JPEG
   - Impact: Faster render times
   - Fix: Resize and convert asset

### LOW (Nice to Have)
1. **Add memoization to particle system**
   - Impact: Negligible performance gain
   - Fix: Wrap in useMemo

Recommendations

## Recommendations

### Code Organization
- Extract ParticleSystem to reusable component
- Consider splitting Scene6 (currently 150 lines)

### Performance
- Preload audio files
- Consider lazy loading large assets

### Maintainability
- Add JSDoc comments to scene components
- Consider extracting animation helpers

Common Issues to Check

Timing Issues

Issue: Incorrect frame calculation

// Wrong
const duration = 5; // Should be 150 frames, not 5

// Correct
const duration = 5 * fps; // 150 frames

Issue: Missing delay

// Wrong - all elements appear at once
const progress = spring({ frame, fps, config: SMOOTH_SPRING });

// Correct - staggered with delays
const progress = spring({
  frame: frame - (index * STAGGER_DELAY),
  fps,
  config: SMOOTH_SPRING
});

Animation Issues

Issue: Inline spring config instead of constant

// Wrong
const progress = spring({
  frame,
  fps,
  config: { damping: 200 },
});

// Correct
const progress = spring({
  frame,
  fps,
  config: SPRING_CONFIGS.smooth,
});

Issue: Repeated calculations

// Wrong
<div style={{
  opacity: spring({ frame, fps, config: SMOOTH }),
  transform: `scale(${spring({ frame, fps, config: SMOOTH })})`,
}} />

// Correct
const progress = spring({ frame, fps, config: SMOOTH });
<div style={{
  opacity: progress,
  transform: `scale(${progress})`,
}} />

Visual Issues

Issue: Hardcoded colors

// Wrong
backgroundColor: '#FF6B35'

// Correct
backgroundColor: COLORS.primary

Issue: Pixel values instead of responsive

// Wrong
left: 960,  // Hardcoded center

// Correct
left: width / 2,  // Responsive center

Asset Issues

Issue: Direct import instead of staticFile

// Wrong
import logo from './logo.png';

// Correct
import { staticFile } from 'remotion';
const logoSrc = staticFile('logo.png');

Performance Issues

Issue: Expensive operation in render

// Wrong - recalculated every frame
const particles = Array.from({ length: 1000 }, (_, i) => ({
  x: Math.random() * width,
  y: Math.random() * height,
}));

// Correct - calculate once
const particles = useMemo(
  () => Array.from({ length: 1000 }, (_, i) => ({
    x: seededRandom(i * 123) * width,
    y: seededRandom(i * 456) * height,
  })),
  [width, height]
);

Review Checklist

Complete review checklist:

Spec Compliance

• All scenes implemented
• Timing matches spec
• Colors match exactly
• Typography matches
• Animations match descriptions
• Audio matches spec

Code Quality

• Constants properly extracted
• Naming conventions followed
• AbsoluteFill used correctly
• TypeScript types defined
• Clean, readable code

Timing

• Frame calculations correct
• Delays calculated properly
• Total duration accurate
• Transitions timed correctly

Visuals

• Colors use constants
• Responsive positioning
• Visual hierarchy clear
• Layer organization logical

Assets

• All assets present
• staticFile used
• Formats appropriate
• Quality sufficient

Performance

• No expensive render calculations
• Progress variables reused
• Assets optimized
• Memoization where needed

Integration with Other Skills

Works with:

• /remotion-spec-translator — Reviews translated code
• /remotion-best-practices — Ensures patterns are followed
• /motion-designer — Compares against original spec
• /remotion-performance-optimizer — Deep performance analysis

Rules Directory

For detailed review criteria:

• rules/spec-compliance.md — Verifying spec accuracy
• rules/timing-review.md — Frame timing validation
• rules/animation-quality.md — Animation assessment
• rules/visual-accuracy.md — Visual fidelity checks
• rules/asset-validation.md — Asset quality review
• rules/performance-audit.md — Performance checking
• rules/code-patterns.md — Code quality standards

This skill ensures Remotion implementations are production-ready, spec-compliant, and follow best practices before deployment.