Communitygithub.com

motion-educator

Crea videos educativos animados premium (explicativos, lecciones, cortometrajes) como películas construidas con código: escenarios iluminados, paneles de vidrio, tipografía metálica, objetos 3D, diagramas, gráficos, subtítulos, narración, música y efectos de sonido, renderizados fotograma a fotograma a MP4.

¿Qué es motion-educator?

Motion Educator es una habilidad para agentes de IA (como Claude Code, Cursor o Codex) que permite crear cortometrajes educativos de alta calidad (20 a 120 segundos) en formato horizontal (16:9) o vertical (9:16). La película se construye como una página web con una línea de tiempo única donde cada fotograma se dibuja al buscarlo, garantizando que nada se pierda y cualquier toma pueda corregirse y re-renderizarse de forma independiente. La habilidad impone un flujo de trabajo riguroso: primero se debe crear un storyboard detallado con fotogramas dibujados para cada toma, que debe pasar una herramienta de validación antes de escribir cualquier código. La narración se escribe como conversación (en indonesio o inglés), se graba en una sola toma con ElevenLabs, y el video se edita al ritmo de la voz. Todos los datos mostrados deben tener fuentes verificables. El motor incluye herramientas para renderizado por lotes, mezcla de audio con medición de sonoridad, y revisión independiente. Está diseñado para desarrolladores y creadores de contenido que necesitan producir videos explicativos animados sobre ciencia, matemáticas, historia, finanzas o conceptos de productos, con un aspecto profesional y sin depender de software de edición de video tradicional. Funciona con Node.js 20+, Playwright, FFmpeg y Python 3.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/zeative/motion-educator/tree/HEAD

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Motion Educator

Creas cortometrajes educativos (de 20 a 120 segundos, explicativos en horizontal o cortos en vertical) que parecen costosos y enseñan bien una cosa. La película es una página web con una línea de tiempo pausada: cada fotograma se dibuja al buscarlo, por lo que nunca se pierde nada y cualquier toma puede corregirse y re-renderizarse por sí sola. El kit en esta habilidad es ese motor. examples/ contiene películas terminadas siguiendo esta habilidad, cada una con su storyboard, código fuente, hoja de señales y narración: langit-biru (solo subtítulos, la más revisada) y petir-guntur (un corto narrado) son las que debes leer primero.

Lee solo la referencia que necesita tu paso actual.

PasoLectura
Decidir qué enseñar y en qué ordenreferences/pedagogy.md
Escribir y dibujar el storyboard (el control)references/storyboard.md
Elegir el estilo, el acento, la iluminación, 3Dreferences/look.md
Construir la película con el kitreferences/engine.md, luego references/motion.md
Escribir la narración: conversación, no subtítulos; registro en indonesio e inglésreferences/narration.md
La voz: elegirla, grabarla en una toma con ElevenLabs, cortar la película a ellareferences/voice.md
Música, efectos de sonido, la mezclareferences/sound.md
Revisar el renderizado, revisión independientereferences/review.md
Renderizar con raea en lugar del navegadorreferences/raea.md

Lo que nunca se dobla

  1. Storyboard primero, y está dibujado. No se escribe ningún archivo de película hasta que storyboard.json pase kit/tools/storyboard.mjs con cero errores y la persona haya visto el tablero. Cada toma tiene fotogramas dibujados (cómo empieza, qué pasa, cómo termina), esbozados en las coordenadas reales del fotograma, para que la construcción pueda cortarse directamente de ellos. Si la persona solicitó una ejecución sin supervisión, envía el tablero y continúa; de lo contrario, espera su aprobación.
  2. Verdadero, con fuentes. Cada número y cada afirmación en pantalla está en la hoja de datos del storyboard con su origen. Si no puedes encontrar la fuente, no lo digas. Lo que se dibuja concuerda con lo que se escribe: una barra, un medidor o una trayectoria que representa un número se calcula a partir de ese número, un diagrama que no está a escala lo dice en pantalla, y un número aparece en su valor (sin contar a través de valores que son falsos).
  3. Se explica a sí mismo en silencio. La imagen y las palabras en pantalla transmiten la explicación; la voz y el sonido la hacen llegar. Un espectador novato con el sonido apagado puede decir lo que aprendió. El paso en el que gira toda la explicación se dibuja como un mecanismo (qué entra, con qué se encuentra, qué sale, dónde termina), nunca se deja solo al subtítulo.
  4. Un solo reloj. Cada valor animado es una función del tiempo de la línea de tiempo. Sin animaciones CSS, sin bucles de requestAnimationFrame, sin Date.now(), sin aleatoriedad no seedeada.
  5. El storyboard es la fuente del tiempo. La película lee los inicios y finales de las tomas de storyboard.json; los subtítulos y la barra de capítulos se generan a partir de él. Cambia el plan allí, nunca a mano en la película. En una película que habla, la grabación escribe esos tiempos (voice.mjs).
  6. No calificas tu propio trabajo. Se revisan fotogramas fijos de cada toma antes de un renderizado completo, se ejecutan mediciones en el renderizado, y un revisor nuevo que no construyó la película juzga el resultado (references/review.md).
  7. Una película que habla se escribe como conversación y se interpreta en una sola toma. El guion se escribe completo y se dice en voz alta antes de que exista cualquier toma; se interpreta una vez, de principio a fin, y la imagen se corta a la voz. Nunca una frase por toma, nunca una grabación por frase, nunca una pausa recortada para ajustarse a un plan.
  8. Di lo que no se revisó. No puedes oír. Di que la mezcla se configuró con mediciones, nombra lo que una persona debería escuchar, y entrega una versión solo con música junto a la mezcla completa.

Flujo de trabajo

0. Un espacio de trabajo

El kit se copia en el proyecto de la persona, nunca se usa desde la propia carpeta de la habilidad.

node <skill>/kit/tools/new.mjs <workspace> <film-name>   # copia kit/ y package.json si falta, crea la estructura films/<film-name>/
cd <workspace> && npm install                            # three.js, GSAP, las fuentes
sh kit/audio/fetch.sh                                    # la biblioteca de sonido (no comprometida: licencia)

Necesita Node 20+, Playwright con Chromium, FFmpeg, y Python 3 con numpy para la mezcla. node kit/tools/doctor.mjs lo comprueba todo y dice qué instalar. Añade --portrait a new.mjs para un corto de 1080x1920.

1. Resumen (unas pocas líneas, en la cabecera del storyboard)

Quién está viendo, qué saben ya, y la promesa: la única frase que pueden decir después de verlo. Una película, una promesa. Si el tema necesita dos promesas, son dos películas. Elige el idioma que lee la audiencia, el formato (horizontal para una lección, vertical para un corto) y si la película habla o explica solo con subtítulos.

2. Investigación y la hoja de datos

Enumera cada afirmación que hará la película, cada una con su fuente, como facts en storyboard.json. Prefiere fuentes primarias e institucionales. Haz la aritmética tú mismo y muéstrala (un número como "5,9x" se escribe con lo que se calcula). Escribe lo que estás simplificando y decide cómo la película será honesta al respecto.

3. El guion, si la película habla

Sigue references/narration.md: una pregunta, escrita como conversación continua en el propio registro de la audiencia, dicha en voz alta y cronometrada, antes de que haya una lista de tomas. Luego córtala en tomas: el voice de cada toma parlante es su parte del guion.

4. El storyboard: el control

Sigue references/storyboard.md. En resumen: actos, luego tomas (una nueva imagen cada tres segundos aproximadamente), cada toma con lo que enseña, su subtítulo, qué hay en pantalla, el movimiento, qué se traslada a la siguiente toma, la transición, el sonido, qué revisar, los hechos que cita, y dos o tres fotogramas dibujados. Corta al ritmo de la música.

node kit/tools/storyboard.mjs films/NAME --png     # cero errores, luego muestra films/NAME/storyboard/*.png

Envía las páginas a la persona. Las hojas de contacto (toda la película en fotogramas) van primero.

5. La grabación, si la película habla

Sigue references/voice.md: elige una voz nativa del idioma (deja que la persona escuche dos o tres si puedes), interpreta todo el guion en una sola toma, y corta la película a ella. Los tiempos del storyboard son los de la grabación de aquí en adelante.

node kit/audio/voice.mjs films/NAME --script                       # la toma a interpretar
node kit/audio/voice.mjs films/NAME --generate                     # con una clave API: la toma y sus tiempos de palabra
node kit/audio/voice.mjs films/NAME --take AUDIO --words WORDS     # con un conector de voz: devuelve ambos
node kit/audio/voice.mjs films/NAME                                # el tiempo de cada toma, y las palabras a escuchar

6. Construir, una toma a la vez

Sigue references/engine.md. Dale a cada toma un <section class="scene"> y anímalo entre s.sNN.start y s.sNN.end. Construye en orden de storyboard y mira un fotograma fijo de cada toma al terminarla:

node kit/tools/render.mjs films/NAME --stills 1.5,4.2,7.9      # fotogramas terminados, unos segundos de trabajo

Compara cada fotograma fijo con su fotograma dibujado. Lo que el fotograma colocó en (x, y) está en (x, y).

7. Renderizar

node kit/tools/render.mjs films/NAME                  # out/picture.mp4, en segmentos de cuatro segundos
node kit/tools/render.mjs films/NAME --only 12-16     # después de una corrección: solo los segmentos que cambiaron

Un minuto de película a 60 fps son aproximadamente media hora en cuatro núcleos de CPU. Ejecútalo en segundo plano y escribe la hoja de señales mientras tanto.

8. Sonido

Sigue references/sound.md: una base musical cuyo ritmo ya coincide con los cortes, y efectos pequeños y limpios sobre eventos reales, escritos como films/NAME/cues.json. Una base compuesta para la película (kit/audio/music.mjs) encaja mejor que una pista de biblioteca cuando la película se va a publicar.

python3 kit/audio/mix.py films/NAME                   # out/NAME.mp4, sonoridad medida en el archivo terminado
python3 kit/audio/mix.py films/NAME --no-sfx --out films/NAME/out/NAME-music-only.mp4

node kit/tools/make.mjs films/NAME ejecuta los comandos de los pasos 4 al 9 en orden (verificar, voz, renderizar, mezclar, medir, una copia para compartir) y se detiene en el primero que falle. No reemplaza mirar fotogramas fijos mientras construyes.

9. Revisar, corregir, verificar

Sigue references/review.md: node kit/tools/check.mjs films/NAME (hojas de contacto, tiempo congelado, sonoridad), luego un revisor nuevo con la película, el storyboard y las propias palabras de la persona. Corrige las brechas más grandes, re-renderiza solo lo que cambió, y pide a un nuevo revisor que verifique la lista. Detente en el estándar de calidad o cuando las mejoras se vuelvan cosméticas. Cuando una corrección cambie lo que muestra una toma, cambia el storyboard para decirlo y redibuja el tablero: el plan y la película nunca discrepan.

10. Entregar

El MP4 (H.264, 1080p60, aproximadamente -14 LUFS, pico verdadero por debajo de -1 dBFS), una copia más ligera para compartir, la versión solo con música, las páginas del storyboard y una breve nota honesta: qué se midió, qué solo se miró, qué nadie ha escuchado, y qué harías a continuación.

Los archivos de una película

films/NAME/
  storyboard.json     el plan: hechos, actos, tomas, fotogramas dibujados. La película lee sus tiempos de aquí
  storyboard.html     el tablero (generado), storyboard/*.png sus páginas
  index.html          un <section class="scene"> por toma o grupo de tomas
  film.css            las piezas de esta película, sobre kit/css/film.css
  film.js             la línea de tiempo, construida con kit/engine/motion.js
  cues.json           la base musical y cada sonido, en el reloj de la película
  voice/              la narración: take.mp3, el tiempo de cada palabra, el corte (voice.json), subtitles.srt
  out/                renderizados (nunca comprometidos)

Estilo de trabajo

  • Planifica donde la persona pueda verlo (el tablero), luego construye sin preguntar en cada paso.
  • Cuando el trabajo se alargue, di en una línea lo que estás haciendo.
  • Muestra el trabajo: el tablero, fotogramas fijos, hojas de contacto, números medidos, el veredicto del revisor.

Skills relacionados