Communitygithub.com

NeverSight/learn-skills.dev

Use esta skill ao criar vídeos programáticos com Remotion, construir composições de vídeo baseadas em React, implementar animações (texto, elemento, transições de cena), renderizar vídeos para MP4/WebM ou configurar projetos Remotion autônomos. Dispara na criação de vídeos, composições Remotion, useCurrentFrame, interpolate, animações spring e renderização de vídeos.

O que é learn-skills.dev?

Esta skill capacita agentes de IA e desenvolvedores a criarem vídeos programáticos usando o framework Remotion com React e TypeScript. Ela abrange desde a configuração inicial do projeto até animações quadro a quadro avançadas, utilizando `interpolate()` para animações previsíveis e `spring()` para movimentos com física natural. A skill fornece orientação detalhada sobre estrutura de composição, sequenciamento de cenas com `Sequence` e `Series`, manipulação de ativos estáticos como imagens e fontes, integração de áudio, e renderização para formatos como MP4 e WebM via linha de comando ou APIs programáticas. Também aborda práticas recomendadas, armadilhas comuns como o uso de `Math.random()` sem sementes ou `setTimeout`, e como lidar com dados assíncronos usando `delayRender()`. É compatível com qualquer plataforma que suporte execução de comandos CLI Remotion e projetos Node.js, sendo ideal para criar vídeos explicativos animados, clipes para redes sociais, visualizações de dados e produção de vídeos personalizados em escala.

Funciona com✓Claude Code✓Codex CLI~Cursor✓Gemini CLI
npx skills add https://github.com/NeverSight/learn-skills.dev/tree/HEAD/data/skills-md/absolutelyskilled/absolutelyskilled/remotion-video

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

:clapper:

Vídeo Remotion

Remotion é um framework para criar vídeos programaticamente usando React. Em vez de editores baseados em linha do tempo, você escreve composições como componentes React onde cada quadro é uma função do número do quadro atual. Isso oferece todo o poder do TypeScript, pacotes npm e arquitetura baseada em componentes para criar vídeos - desde explicadores animados e clipes para redes sociais até visualizações baseadas em dados e vídeos personalizados em escala.

Esta skill cobre configuração de projeto, estrutura de composição, animações baseadas em quadros com interpolate e spring, sequenciamento de cenas, gerenciamento de ativos, integração de áudio, vídeos parametrizados com esquemas Zod e renderização para MP4/WebM via CLI ou APIs programáticas.


Quando usar esta skill

Ative esta skill quando o usuário:

  • Quer criar um vídeo programaticamente usando React/TypeScript
  • Pergunta sobre composições Remotion, useCurrentFrame ou useVideoConfig
  • Precisa animar texto, elementos ou transições entre cenas
  • Quer renderizar um vídeo para MP4, WebM ou GIF a partir de código
  • Pergunta sobre animações spring, interpolate ou temporização baseada em quadros
  • Precisa configurar um novo projeto Remotion do zero
  • Quer adicionar áudio, imagens ou fontes a um vídeo Remotion
  • Pergunta sobre geração de vídeos parametrizados / baseados em dados
  • Precisa configurar o Remotion Studio para visualizar composições

NÃO ative esta skill para:

  • Perguntas gerais sobre React não relacionadas à criação de vídeos - use skills de React
  • Edição de vídeo com ferramentas tradicionais de linha do tempo (Premiere, DaVinci, FFmpeg CLI)
  • Animações CSS para páginas web - use skills de animação / motion design
  • Reprodução ou streaming de vídeo em aplicações web - use skills de player de mídia

Princípios-chave

  1. Cada quadro é uma função pura - Um componente Remotion recebe o quadro atual via useCurrentFrame() e deve renderizar deterministicamente para aquele quadro. Sem efeitos colaterais, sem aleatoriedade sem sementes, sem dependência do tempo real. O mesmo número de quadro deve sempre produzir a mesma saída visual.

  2. Composições são a unidade do vídeo - Cada <Composition> define um vídeo com dimensões explícitas (largura, altura), taxa de quadros (fps) e duração (durationInFrames). Pense nas composições como "páginas" do seu projeto - uma por variante de vídeo ou cena que pode ser renderizada independentemente.

  3. Interpolate para tudo - A função interpolate() mapeia números de quadro para qualquer valor numérico (opacidade, posição, escala, canais de cor). Combinada com extrapolateRight: 'clamp', é o carro-chefe para todas as animações. Use spring() quando precisar de easing baseado em física.

  4. Sequence para deslocamentos de tempo - Use <Sequence from={frame}> para atrasar quando os filhos começam a aparecer, e <Series> para reproduzir filhos um após o outro. Nunca use setTimeout ou matemática manual de quadros para sequenciamento - as primitivas declarativas lidam com isso corretamente tanto na visualização quanto na renderização.

  5. Ativos são estáticos, dados são dinâmicos - Coloque imagens, fontes e arquivos de áudio na pasta public/ e referencie-os com staticFile(). Para dados dinâmicos (respostas de API, registros de banco de dados), use delayRender() / continueRender() para pausar a renderização até que os dados sejam carregados.


Conceitos principais

Estrutura de composição

Todo projeto Remotion tem um arquivo raiz que registra as composições:

import { Composition } from 'remotion';
import { MyVideo } from './MyVideo';

export const RemotionRoot: React.FC = () => {
  return (
    <Composition
      id="MyVideo"
      component={MyVideo}
      durationInFrames={150}
      fps={30}
      width={1920}
      height={1080}
    />
  );
};

Temporização baseada em quadros

Toda temporização no Remotion é expressa em quadros, não em segundos. Para converter:

  • Segundos para quadros: segundos * fps
  • Quadros para segundos: quadros / fps

A 30 fps, um vídeo de 5 segundos tem 150 quadros. O quadro 0 é o primeiro quadro.

Modelo de animação

Remotion fornece duas primitivas principais de animação:

PrimitivaCaso de usoExemplo
interpolate()Mapeamento linear/clamped de quadro para valorFade, slide, escala
spring()Animação baseada em física com amortecimento/massaEntradas saltitantes, movimento natural

Ambas retornam um número que você aplica aos estilos (opacidade, transform, etc.).


Tarefas comuns

1. Configurar um novo projeto Remotion

npx create-video@latest

Isso cria um projeto com TypeScript, uma composição de exemplo e o Remotion Studio configurado. A estrutura do projeto será:

meu-video/
  src/
    Root.tsx          # Registra todas as composições
    MeuComp.tsx        # Seu primeiro componente de composição
  public/             # Ativos estáticos (imagens, fontes, áudio)
  remotion.config.ts  # Configuração do Remotion
  package.json

Inicie o estúdio de visualização com:

npx remotion studio

2. Criar uma composição básica com useCurrentFrame

import { AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';

export const TextoFadeIn: React.FC = () => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();

  const opacidade = interpolate(frame, [0, 30], [0, 1], {
    extrapolateRight: 'clamp',
  });

  const deslocamentoY = interpolate(frame, [0, 30], [20, 0], {
    extrapolateRight: 'clamp',
  });

  return (
    <AbsoluteFill
      style={{
        justifyContent: 'center',
        alignItems: 'center',
        backgroundColor: '#0f0f0f',
      }}
    >
      <h1
        style={{
          fontSize: 80,
          color: 'white',
          opacity: opacidade,
          transform: `translateY(${deslocamentoY}px)`,
        }}
      >
        Olá Remotion
      </h1>
    </AbsoluteFill>
  );
};

3. Animar texto palavra por palavra

Divida o texto em palavras e escalone a aparição de cada palavra usando <Sequence>:

import { AbsoluteFill, Sequence, useCurrentFrame, interpolate } from 'remotion';

const PalavraAnimada: React.FC<{ children: string }> = ({ children }) => {
  const frame = useCurrentFrame();
  const opacidade = interpolate(frame, [0, 15], [0, 1], {
    extrapolateRight: 'clamp',
  });
  const deslocamentoY = interpolate(frame, [0, 15], [10, 0], {
    extrapolateRight: 'clamp',
  });

  return (
    <span
      style={{
        display: 'inline-block',
        opacity: opacidade,
        transform: `translateY(${deslocamentoY}px)`,
        marginRight: 12,
      }}
    >
      {children}
    </span>
  );
};

export const PalavraPorPalavra: React.FC<{ text: string }> = ({ text }) => {
  const palavras = text.split(' ');

  return (
    <AbsoluteFill
      style={{
        justifyContent: 'center',
        alignItems: 'center',
        backgroundColor: '#1a1a2e',
        flexWrap: 'wrap',
        padding: 100,
      }}
    >
      {palavras.map((palavra, i) => (
        <Sequence key={i} from={i * 8}>
          <PalavraAnimada>{palavra}</PalavraAnimada>
        </Sequence>
      ))}
    </AbsoluteFill>
  );
};

4. Animações de elemento com spring

Use spring() para animações baseadas em física que parecem naturais:

import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring } from 'remotion';

export const CartaoSpring: React.FC = () => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();

  const escala = spring({
    frame,
    fps,
    config: { damping: 200, stiffness: 100, mass: 0.5 },
  });

  const deslizarParaCima = spring({
    frame: frame - 10,
    fps,
    config: { damping: 12, stiffness: 100 },
  });

  return (
    <AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center', backgroundColor: '#0d1117' }}>
      <div
        style={{
          width: 400,
          height: 250,
          backgroundColor: '#161b22',
          borderRadius: 16,
          transform: `scale(${escala}) translateY(${(1 - deslizarParaCima) * 50}px)`,
        }}
      >
        <p style={{ color: 'white', fontSize: 32 }}>Animação Spring</p>
      </div>
    </AbsoluteFill>
  );
};

5. Transições de cena com Sequence e Series

Use <Sequence> para cenas sobrepostas e <Series> para reprodução sequencial:

import { AbsoluteFill, Sequence, Series, useCurrentFrame, interpolate } from 'remotion';

const Cena: React.FC<{ color: string; title: string }> = ({ color, title }) => {
  const frame = useCurrentFrame();
  const opacidade = interpolate(frame, [0, 20], [0, 1], {
    extrapolateRight: 'clamp',
  });

  return (
    <AbsoluteFill style={{ backgroundColor: color, justifyContent: 'center', alignItems: 'center' }}>
      <h1 style={{ color: 'white', fontSize: 72, opacity: opacidade }}>{title}</h1>
    </AbsoluteFill>
  );
};

export const MultiCena: React.FC = () => {
  return (
    <AbsoluteFill>
      <Series>
        <Series.Sequence durationInFrames={60}>
          <Cena color="#e63946" title="Cena Um" />
        </Series.Sequence>
        <Series.Sequence durationInFrames={60}>
          <Cena color="#457b9d" title="Cena Dois" />
        </Series.Sequence>
        <Series.Sequence durationInFrames={60}>
          <Cena color="#2a9d8f" title="Cena Três" />
        </Series.Sequence>
      </Series>
    </AbsoluteFill>
  );
};

6. Manipulação de ativos (imagens, fontes, staticFile)

Referencie ativos estáticos da pasta public/ usando staticFile():

import { AbsoluteFill, Img, staticFile } from 'remotion';

export const DemonstracaoAtivo: React.FC = () => {
  return (
    <AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
      <Img
        src={staticFile('logo.png')}
        style={{ width: 300, height: 300 }}
      />
    </AbsoluteFill>
  );
};

Carregue fontes personalizadas com @remotion/google-fonts ou CSS @font-face:

import { loadFont } from '@remotion/google-fonts/Inter';

const { fontFamily } = loadFont();

export const DemonstracaoFonte: React.FC = () => {
  return (
    <AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
      <h1 style={{ fontFamily, fontSize: 64, color: 'white' }}>
        Fonte Personalizada
      </h1>
    </AbsoluteFill>
  );
};

7. Integração de áudio

Adicione áudio com controle de volume e temporização:

import { AbsoluteFill, Audio, Sequence, staticFile, interpolate } from 'remotion';

export const ComAudio: React.FC = () => {
  return (
    <AbsoluteFill style={{ backgroundColor: '#000' }}>
      <Audio
        src={staticFile('musica-de-fundo.mp3')}
        volume={(f) =>
          interpolate(f, [0, 30, 120, 150], [0, 0.8, 0.8, 0], {
            extrapolateLeft: 'clamp',
            extrapolateRight: 'clamp',
          })
        }
      />
      <Sequence from={15}>
        <Audio src={staticFile('whoosh.mp3')} volume={0.5} />
      </Sequence>
    </AbsoluteFill>
  );
};

8. Renderização de vídeos

Renderize para MP4 a partir da linha de comando:

# Renderizar composição padrão
npx remotion render src/index.ts MeuVideo out/video.mp4

# Renderizar em resolução 4K
npx remotion render src/index.ts MeuVideo out/video.mp4 --width 3840 --height 2160

# Renderizar para WebM
npx remotion render src/index.ts MeuVideo out/video.webm --codec vp8

# Renderizar um intervalo específico de quadros
npx remotion render src/index.ts MeuVideo out/video.mp4 --frames 0-90

# Renderizar com props personalizadas
npx remotion render src/index.ts MeuVideo out/video.mp4 --props '{"title": "Olá"}'

Para renderização programática, consulte references/rendering-guide.md.


Anti-padrões / erros comuns

ErroPor que está erradoO que fazer em vez disso
Usar Math.random() sem uma sementeProduz saída diferente por quadro durante a renderizaçãoUse uma semente determinística ou random() do Remotion
Usar setTimeout / setIntervalQuebra a renderização baseada em quadros - temporizadores não avançam por quadroUse useCurrentFrame() e matemática de quadros para toda a temporização
Faltando extrapolateRight: 'clamp'Valores ultrapassam o intervalo alvo em quadros posterioresSempre adicione { extrapolateRight: 'clamp' } ao interpolate()
Codificar fps nos cálculos de quadrosQuebra quando o fps da composição mudaUse useVideoConfig().fps para derivar a temporização
Usar <Video> para saída renderizadaDesempenho de renderização mais lento devido à sobrecarga de buscaUse <OffthreadVideo> para melhor desempenho de renderização
Esquecer delayRender() para dados assíncronosRenderiza antes do carregamento dos dados, mostrando quadros vazios/quebradosChame delayRender() imediatamente, continueRender() quando pronto
Estilos inline com valores não determinísticosCintilações ou inconsistência entre visualização e renderizaçãoDerive todos os valores de estilo apenas do número do quadro
Composição única giganteDifícil de manter e impossível renderizar cenas independentementeDivida em múltiplas composições ou use Series para cenas

Armadilhas

  1. O padrão extrapolateRight é 'extend' - Se você escrever interpolate(frame, [0, 30], [0, 1]) sem clamp, o valor continuará aumentando além de 1 após o quadro 30 (por exemplo, o quadro 60 dá opacidade 2). Sempre passe { extrapolateRight: 'clamp' } a menos que você queira intencionalmente a extrapolação.

  2. spring() começa do quadro 0 do seu contexto - Ao usar spring() dentro de um <Sequence from={60}>, o quadro passado para spring reinicia para 0 no quadro 60 do pai. Se você passar o quadro bruto do pai, a animação já estará completa. Use useCurrentFrame() dentro do filho do Sequence, não um quadro do pai.

  3. Os caminhos de staticFile() são relativos a public/ - Chamar staticFile('images/logo.png') procura por public/images/logo.png. Usar caminhos absolutos ou caminhos fora de public/ falhará silenciosamente na visualização e gerará erro durante a renderização. Certifique-se de que todos os ativos estejam no diretório public/.

  4. delayRender tem um tempo limite de 30 segundos - Se sua operação assíncrona (chamada de API, carregamento de fonte) demorar mais de 30 segundos, a renderização será abortada. Aumente o tempo limite com delayRender('Carregando dados', { timeoutInMilliseconds: 60000 }) para operações lentas.

  5. As dimensões da composição devem ser números pares - Codecs de vídeo (H.264, VP8) exigem largura e altura pares. O Remotion lançará um erro se você tentar renderizar uma composição com dimensões ímpares. Sempre garanta que a largura e a altura sejam números pares.

  6. Mudanças de código durante a renderização não são refletidas - O Remotion compila seu código antes da renderização. Se você modificar arquivos de origem enquanto um vídeo está sendo renderizado, as alterações não serão incluídas até que você reinicie o processo de renderização. Sempre pare e reinicie a renderização após alterações no código.


Plataformas compatíveis

  • Remotion Studio - Ambiente de desenvolvimento integrado para visualização e iteração de composições
  • Linha de comando - Renderização via npx remotion render
  • Renderização programática - API Node para integração em pipelines
  • Lambda - Renderização em escala com AWS Lambda (pacote @remotion/lambda)

Tópicos avançados

Vídeos Parametrizados

Use um esquema Zod para definir props que podem ser passadas ao renderizar:

import { z } from 'zod';
import { Composition } from 'remotion';

export const meuEsquema = z.object({
  titulo: z.string(),
  cor: z.string(),
});

// No Root.tsx:
<Composition
  id="VideoParametrizado"
  component={ParamVideo}
  durationInFrames={150}
  fps={30}
  width={1920}
  height={1080}
  schema={meuEsquema}
  defaultProps={{
    titulo: 'Olá',
    cor: '#ff0000',
  }}
/>

Dados Assíncronos

Use delayRender e continueRender para dados baseados em API:

import { AbsoluteFill, useCurrentFrame, delayRender, continueRender, interpolate, staticFile, Img, Audio, Sequence, Series, spring, loadFont, Composition } from 'remotion';
import { useEffect, useState } from 'react';

export const VideoAssincrono: React.FC = () => {
  const [dados, setDados] = useState(null);
  const [handle] = useState(() => delayRender());

  useEffect(() => {
    fetch('https://api.exemplo.com/dados')
      .then((res) => res.json())
      .then((dados) => {
        setDados(dados);
        continueRender(handle);
      });
  }, [handle]);

  if (!dados) return null;

  // Renderizar usando os dados
  return (
    <AbsoluteFill style={{ backgroundColor: '#000', justifyContent: 'center', alignItems: 'center' }}>
      <h1 style={{ color: 'white' }}>{dados.titulo}</h1>
    </AbsoluteFill>
  );
};

Referências


Dicas de resolução de problemas

Erro: "O arquivo não pôde ser lido"

  • Verifique se o caminho em staticFile() está correto
  • Verifique se o ativo está realmente no diretório public/
  • Verifique se o nome do arquivo tem a extensão correta

Erro: "A renderização falhou"

  • Verifique se todas as dependências estão instaladas
  • Certifique-se de que as dimensões da composição são números pares
  • Certifique-se de que você não está usando Math.random sem semente
  • Verifique se os dados assíncronos estão sendo carregados corretamente com delayRender

Animação não aparece

  • Certifique-se de que você está usando useCurrentFrame() para obter o quadro atual
  • Certifique-se de que você está aplicando valores interpolados ou spring aos estilos
  • Verifique se a composição tem a duração correta em frames

Considerações finais

Com Remotion, você tem o poder do React para criar vídeos. Lembre-se dos princípios-chave: cada quadro é uma função pura, use as primitivas declarativas para temporização e animação, e sempre garanta que seus ativos estejam no lugar certo. Com esta skill, você pode criar desde animações simples até vídeos personalizados complexos em escala.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

NeverSight/learn-skills.dev

Use when generating or modifying Remotion video code, creating demo videos, or working with the demo-video/ directory

NeverSight/learn-skills.dev

Create AI avatar and talking head videos via inference.sh CLI. Recommended: P-Video-Avatar (fastest, cheapest, built-in TTS). Also: OmniHuman, Fabric, PixVerse. Audio: Inworld TTS-2 (100+ languages, emotion steering for characters), ElevenLabs, Kokoro. Capabilities: audio-driven avatars, text-to-avatar, lipsync videos, talking head generation, virtual presenters, UGC content. Use for: AI presenters, explainer videos, virtual influencers, dubbing, marketing videos, UGC ads, gaming avatars, NPC dialogue. Triggers: ai avatar, talking head, lipsync, avatar video, virtual presenter, ai spokesperson, audio driven video, heygen alternative, synthesia alternative, talking avatar, lip sync, video avatar, ai presenter, digital human, ugc, ugc video, ugc ad, avatar ugc

NeverSight/learn-skills.dev

Create AI marketing videos for ads, promos, product launches, and brand content. Models: Veo, Seedance, Wan, FLUX for visuals, Kokoro for voiceover. Types: product demos, testimonials, explainers, social ads, brand videos. Use for: Facebook ads, YouTube ads, product launches, brand awareness. Triggers: marketing video, ad video, promo video, commercial, brand video, product video, explainer video, ad creative, video ad, facebook ad video, youtube ad, instagram ad, tiktok ad, promotional video, launch video

NeverSight/learn-skills.dev

Generate AI videos with Google Veo, Seedance 2.0, HappyHorse, Wan, Grok and 40+ models via inference.sh CLI. Models: Veo 3.1, Veo 3, Seedance 2.0, HappyHorse 1.0, Wan 2.5, Grok Imagine Video, OmniHuman, Fabric, HunyuanVideo. Capabilities: text-to-video, image-to-video, reference-to-video, video editing, lipsync, avatar animation, video upscaling, foley sound. Use for: social media videos, marketing content, explainer videos, product demos, AI avatars. Triggers: video generation, ai video, text to video, image to video, veo, animate image, video from image, ai animation, video generator, generate video, t2v, i2v, ai video maker, create video with ai, runway alternative, pika alternative, sora alternative, kling alternative, seedance, happyhorse

NeverSight/learn-skills.dev

ElevenLabs automatic dubbing - translate and dub audio/video into 29 languages while preserving speaker voice via inference.sh CLI. Capabilities: auto speaker detection, voice-preserving translation, video dubbing, audio localization. Use for: content localization, video translation, multilingual content, international distribution. Triggers: dubbing, dub video, translate audio, video translation, audio translation, localize content, elevenlabs dubbing, eleven labs dub, multilingual dub, voice translation, auto dub, language dub, content localization

NeverSight/learn-skills.dev

Explainer video production guide: scripting, voiceover, visuals, and assembly. Covers script formulas, pacing rules, scene planning, and multi-tool pipelines. Use for: product demos, how-it-works videos, onboarding videos, social explainers. Triggers: explainer video, how to make explainer, product video, demo video, video production, video script, animated explainer, product demo video, tutorial video, onboarding video, walkthrough video, video pipeline

NeverSight/learn-skills.dev

Still-to-video conversion guide: model selection, motion prompting, and camera movement. Covers Wan 2.5 i2v, Seedance, Fabric, Grok Video with when to use each. Use for: animating images, creating video from stills, adding motion, product animations. Triggers: image to video, i2v, animate image, still to video, add motion to image, image animation, photo to video, animate still, wan i2v, image2video, bring image to life, animate photo, motion from image

NeverSight/learn-skills.dev

Generate talking head avatar videos with Pruna P-Video-Avatar via inference.sh CLI. Turn a portrait image into a realistic speaking video with built-in TTS. 18x faster and 6x cheaper than competitors. Models: P-Video-Avatar, P-Image (for portrait generation). Capabilities: text-to-avatar, audio-driven avatars, 30 voices, 10 languages, 720p/1080p, built-in TTS, dynamic backgrounds, full-body control. Use for: AI presenters, product demos, explainer videos, virtual influencers, marketing, education, multilingual content, UGC, gaming avatars. Triggers: avatar video, talking head, ai avatar, p-video-avatar, pruna avatar, video avatar, ai presenter, digital human, virtual presenter, lipsync, talking avatar, ai spokesperson, heygen alternative, synthesia alternative, veed alternative, fabric alternative, omnihuman alternative

NeverSight/learn-skills.dev

Generate videos with Pruna P-Video and WAN models via inference.sh CLI. Models: P-Video, WAN-T2V, WAN-I2V. Capabilities: text-to-video, image-to-video, audio support, 720p/1080p, fast inference. Pruna optimizes models for speed without quality loss. Triggers: pruna video, p-video, pruna ai video, fast video generation, optimized video, wan t2v, wan i2v, economic video generation, cheap video generation, pruna text to video, pruna image to video

NeverSight/learn-skills.dev

Render videos from React/Remotion component code via inference.sh. Pass TSX code, get MP4. Supports all Remotion APIs: useCurrentFrame, useVideoConfig, spring, interpolate, AbsoluteFill, Sequence. Configurable resolution, FPS, duration, codec. Use for: programmatic video generation, animated graphics, motion design, data-driven videos, React animations to video. Triggers: remotion, render video from code, tsx to video, react video, programmatic video, remotion render, code to video, animated video, motion graphics code, react animation video

NeverSight/learn-skills.dev

Video ad creation with exact platform-specific specs for TikTok, Instagram, YouTube, Facebook, LinkedIn. Covers dimensions, duration limits, AIDA framework, and caption requirements. Use for: video ads, social media ads, paid media creative, video marketing, ad production. Triggers: video ad, social media ad, tiktok ad, instagram ad, youtube ad, facebook ad, linkedin ad, video creative, ad specs, paid media, video marketing, ad production, reels ad, stories ad, pre roll, bumper ad

NeverSight/learn-skills.dev

Best practices and techniques for writing effective AI video generation prompts. Covers: Veo, Seedance, Wan, Grok, Kling, Runway, Pika, Sora prompting strategies. Learn: shot types, camera movements, lighting, pacing, style keywords, negative prompts. Use for: improving video quality, getting consistent results, professional video prompts. Triggers: video prompt, how to prompt video, veo prompts, video generation tips, better ai video, video prompt engineering, video prompt guide, video prompt template, ai video tips, video prompt best practices, video prompt examples, cinematography prompts

NeverSight/learn-skills.dev

YouTube thumbnail design with specific dimensions, contrast rules, and mobile preview optimization. Covers safe zones, text placement, face expression psychology, and A/B testing. Use for: YouTube thumbnails, video cover images, click-through optimization. Triggers: youtube thumbnail, thumbnail design, video thumbnail, click through rate, ctr optimization, youtube cover, video cover image, thumbnail maker, thumbnail tips, youtube design, video preview image

NeverSight/learn-skills.dev

Landing page conversion optimization with layout rules, hero section design, and CTA psychology. Covers above-the-fold formula, social proof placement, mobile design, and F-pattern reading. Use for: startup landing pages, product pages, SaaS marketing, conversion optimization. Triggers: landing page, hero section, above the fold, conversion optimization, landing page design, cta button, hero image, landing page layout, saas landing page, product page design, conversion rate, landing page best practices

NeverSight/learn-skills.dev

Configure and use the hosted YouTube Data MCP end-to-end with minimal user input. Use when users want the agent to verify Node.js and `npx`, configure MCP server config (Windows/macOS, Cursor/Codex/OpenClaw/OpenCode), request API key at setup time, run post-install capability discovery (`tools/list` and `get_patch_notes`), and then strongly recommend helper skill and Python setup for full local document and spreadsheet workflows.

NeverSight/learn-skills.dev

Creates 120fps GPU-accelerated animations with Motion.dev (Framer Motion successor) for React, Next.js, Svelte, and Astro projects. Use when user requests animation, motion, scroll effects, parallax, hero animations, gestures, drag interactions, spring physics, whileHover effects, whileInView animations, animated UI, micro-interactions, page transitions, or layout animations. Generates production TypeScript/JSX code with accessibility (prefers-reduced-motion) and performance validation (≥60fps). Supports entrance animations, gesture interactions (hover/tap/drag), scroll-based reveals, and layout transitions using spring physics and natural timing. Do NOT use for CSS-only transitions (use native CSS), static sites without JavaScript, Vue animations (use motion-v variant instead), or SVG/Canvas complex animations (GSAP better suited).

NeverSight/learn-skills.dev

Static artifact craft skill for self-contained HTML/CSS/JS documents: docs, sheets, dashboards, explainers, slides, tools, and landing pages. Use when the user asks for a durable, openable, shareable web deliverable they'll keep or hand off — a report, a dashboard, a slide deck, a data table, a page. Local folder first, temporary public link via tunnel (localhost.run), optional durable publish to Surge, GitHub Pages, or Cloudflare. Not for quick look renders, inline snippets, or throwaway scratch. Not for SPA frameworks, backend APIs, database apps, or production product UI.

NeverSight/learn-skills.dev

FFmpeg commands for video/audio conversion, trimming, compression, and processing. Use when user mentions "ffmpeg", "convert video", "compress video", "extract audio", "trim video", "gif from video", "video codec", "transcode", "screen recording", "merge videos", "video to mp4", "reduce file size", or any media processing task.

NeverSight/learn-skills.dev

Vim keybindings, motions, text objects, and operators for efficient text editing. Use when user asks about "vim commands", "vim motions", "text objects", "vim keybindings", "vim cheat sheet", "learn vim", "vim in VS Code", or any Vim editing tasks.

NeverSight/learn-skills.dev

Grok Build ONLY. Turn a 2D character still into smooth animation sprites via image_gen/image_edit base → image_to_video (6s/10s run-in-place) → ffmpeg frames → magenta chroma-key → dense sampled sprites (strip/grid/GIF). Use when the user wants video-to-sprite, motion capture from generated video, smoother run/walk cycles from dense frames, or runs /video2dsprite. Do NOT use on Codex/Claude — only Grok Build has image_to_video. Prefer generate2dsprite for crisp pixel sheets without video.

Habilidades Relacionadas