Skip to content
Back to search

presentaciones-motion

Crea presentaciones de diapositivas en un solo archivo HTML, navegables con flechas, con motion graphics de verdad (ilustraciones y diagramas animados en SVG, CSS y canvas), interstitials de puro movimiento y slides que se explican paso a paso, con una vista en vivo que muestra el avance mientras se construye, un editor tipo PowerPoint (alinear, copiar y pegar, insertar texto, formas e imágenes, rotar, capas) y exportación a PDF y PowerPoint; el resultado es un solo archivo fácil de compartir. Úsala siempre que el usuario pida una presentación, clase, charla, exposición, deck, diapositivas o slides para presentar en vivo, pida motion graphics o animaciones para sus slides, o quiera agregar, cambiar, animar, retocar a mano, exportar o compartir slides de una presentación hecha con esta skill, aunque no diga "HTML".

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mariourenagarcia--presentaciones-motion/badge.svg)](/listings/mariourenagarcia--presentaciones-motion)

HTML

<a href="/listings/mariourenagarcia--presentaciones-motion"><img src="/api/listings/mariourenagarcia--presentaciones-motion/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 260 lines
  1. ---
  2. name: presentaciones-motion
  3. description: Crea presentaciones de diapositivas en un solo archivo HTML, navegables con flechas, con motion graphics de verdad (ilustraciones y diagramas animados en SVG, CSS y canvas), interstitials de puro movimiento y slides que se explican paso a paso, con una vista en vivo que muestra el avance mientras se construye, un editor tipo PowerPoint (alinear, copiar y pegar, insertar texto, formas e imágenes, rotar, capas) y exportación a PDF y PowerPoint; el resultado es un solo archivo fácil de compartir. Úsala siempre que el usuario pida una presentación, clase, charla, exposición, deck, diapositivas o slides para presentar en vivo, pida motion graphics o animaciones para sus slides, o quiera agregar, cambiar, animar, retocar a mano, exportar o compartir slides de una presentación hecha con esta skill, aunque no diga "HTML".
  4. ---
  5. # Presentaciones con motion graphics
  6. Producto: un único `.html` autocontenido (fuentes embebidas, sin internet) que el presentador pasa con las flechas,
  7. espacio o clic; F pone pantalla completa, B la pone en negro y G abre la galería de miniaturas para saltar a
  8. cualquier slide. Cada slide de contenido tiene una ilustración animada
  9. que explica la idea; entre secciones hay interstitials de puro movimiento; las slides complejas avanzan paso a paso.
  10. El `.html` entregable existe desde el primer minuto y se reescribe solo con cada avance: al principio con todas
  11. las slides como pendientes y después con cada slide que queda lista. Nunca se espera al final para escribirlo.
  12. Mientras se construye, el usuario ve el deck en una vista en vivo que se actualiza sola (sin capturas en el chat):
  13. primero aparecen todas las slides como pendientes y cada una se reemplaza en cuanto su bloque queda listo. En esa
  14. misma vista puede pulsar E y se abre un editor tipo PowerPoint: panel de slides con miniaturas, cinta de
  15. herramientas y panel de propiedades. Selecciona uno o varios elementos, los mueve con guías, escala y rota con manijas,
  16. alinea y distribuye, copia, corta, pega y duplica (también entre slides), inserta texto, rectángulos, círculos,
  17. líneas e imágenes (desde archivo, pegadas o arrastradas), cambia colores del tema, tamaño de letra, negrita, cursiva,
  18. opacidad y capas, deshace y rehace, y exporta. Al guardar, todo queda en los archivos fuente.
  19. Para compartir basta el `.html`: es un solo archivo con fuentes e imágenes adentro, funciona sin internet y abre en
  20. cualquier navegador. Si piden PDF o PowerPoint, `scripts/exportar.py` (o Exportar en el editor) los genera junto al HTML.
  21. La skill trae el motor (`assets/shell.html`), los scripts (`scripts/build.py`, `scripts/esqueleto.py`, `scripts/vivo.py`,
  22. `scripts/shot.mjs`, `scripts/hoja.py`, `scripts/nav.mjs`, `scripts/miniaturas.py`, `scripts/recorrido.mjs`,
  23. `scripts/exportar.py`), el cliente de la vista en vivo y del editor
  24. (`assets/vivo/cliente.js`),
  25. el brief para quien construye slides (`references/brief.md`), la API del motor (`references/motor.md`), los estilos
  26. por tema (`references/estilos.md`) y ejemplos reales (`assets/ejemplos/`).
  27. ## Flujo
  28. ### 1. Entender el encargo
  29. Saca de la conversación o pregunta lo que falte de verdad: tema y puntos a cubrir, público (técnico o no), duración
  30. o número de slides, tono y dónde se va a presentar. Si el usuario ya dio una lista de temas, no la reinterpretes:
  31. cúbrela completa y en su orden, y avisa si propones mover algo.
  32. ### 2. Datos
  33. Toda cifra que vaya a pantalla se verifica en la web y se anota en `DATOS.md` (cifra, fuente, año). Si no se puede
  34. verificar, no entra. Preferir fuentes primarias (informes originales) y decir en la slide de dónde sale. Si la
  35. presentación no lleva cifras, no hace falta `DATOS.md`. La etiqueta "PASO 03 / 06" de una slide con pasos es
  36. navegación, no una cifra.
  37. ### 3. Estilo
  38. Lee `references/estilos.md`, elige paleta y fuentes según el tema, el público y el lugar, dilo en una línea y
  39. sigue. Si el usuario nombra un estilo o trae su propia paleta (colores de su marca, de su escuela), úsala. No hay un
  40. estilo por defecto: una charla de negocios, una clase para niños y un taller técnico no deben verse iguales.
  41. ### 4. Carpeta del deck y guion
  42. En el proyecto del usuario crea `fuente-presentacion/` con:
  43. - `deck.json`: copia `assets/deck.ejemplo.json` y ajusta `titulo`, `tema`, `fuentes` y `salida`. `salida` es
  44. obligatoria: es el HTML entregable, relativo a `fuente-presentacion/` (por ejemplo `../Titulo-Corto.html`), así
  45. el archivo no guarda rutas personales.
  46. - `GUION.md`: la lista de slides en orden, agrupadas en bloques de 4 a 6 slides contiguas; cada bloque será
  47. `parts/NN-nombre.html`. Un deck de 6 slides o menos es un solo bloque. Usa este formato, porque `esqueleto.py`
  48. lo lee para crear las slides pendientes:
  49. ```
  50. ## 01-apertura
  51. ### portada
  52. Etiqueta: Ciencia en la cocina
  53. Título: Del grano a la taza
  54. Texto: frase de apoyo o puntos, si los hay
  55. Visual: taza en line-art con vapor que sube en loop
  56. Datos: cifra (fuente, año), si la slide lleva alguna
  57. ### i-granos [interstitial]
  58. Visual: granos que caen en espiral
  59. ### proceso [pasos]
  60. ```
  61. - Interstitials: no cuentan como slides. Ponlos entre secciones en decks de unas 10 slides o más. Si el usuario
  62. fija un número corto de slides, no los agregues salvo que los pida.
  63. - `parts/`, vacía, y `fonts/` solo si usas fuentes que no trae la skill.
  64. Builds de prueba y capturas van al scratchpad de la sesión, no al proyecto. En `fuente-presentacion/` no van
  65. conversaciones, prompts ni el brief: solo el contenido de la presentación.
  66. Muéstrale al usuario el guion resumido (títulos y visuales) en el chat y arranca sin esperar, salvo que haya una
  67. decisión que de verdad sea suya.
  68. ### 4b. Entregable y vista en vivo, antes de construir (obligatorio)
  69. ```bash
  70. python -I "<SKILL>/scripts/esqueleto.py" "<DECK>" # pendientes + primer entregable
  71. python -I "<SKILL>/scripts/vivo.py" "<DECK>" --respaldos "<TMP>/respaldos" # en segundo plano
  72. ```
  73. `esqueleto.py` crea una slide pendiente por cada slide del guion y escribe el HTML entregable en la ruta `salida`
  74. (imprime `ENTREGABLE <ruta> (0 de N slides listas)`). Desde ese momento el entregable existe y va al día:
  75. - `vivo.py` lo reescribe cada vez que cambia una parte (lo hace un subagente, tú o el usuario con el editor).
  76. - `build.py` también lo reescribe en cada ensamblado completo, aunque `vivo.py` no esté corriendo.
  77. - Las slides que faltan salen como "EN CONSTRUCCIÓN"; nunca se espera al final para escribir el archivo.
  78. Lanza `vivo.py` en segundo plano (no lo esperes) y lee la URL que imprime (`http://127.0.0.1:4610/` o el siguiente
  79. puerto libre). Ábrela en el navegador integrado de la app si está disponible y dale al usuario dos cosas: la URL de la
  80. vista en vivo y la ruta del HTML entregable, que puede abrir cuando quiera y siempre tiene lo último. Explícale en dos
  81. líneas: la vista se actualiza sola mientras se construye; con E se abre el editor tipo PowerPoint (clic selecciona,
  82. doble clic reescribe, Ctrl+S guarda; el resto está en la cinta de arriba). Desde ahí el avance se ve en vivo: no
  83. mandes capturas al chat. Las capturas de `shot.mjs` son para tu revisión interna. Para saber cuántas slides faltan y
  84. cuándo se actualizó el entregable: `curl -s http://127.0.0.1:<puerto>/__vivo/estado` (campo `entregable`).
  85. ### 5. Construir en paralelo
  86. Si hay dos bloques o más y puedes lanzar subagentes, lanza uno por bloque en el mismo mensaje (hasta 6) y quédate
  87. coordinando. Cada
  88. prompt lleva: la ruta de `references/brief.md` para que lo lea completo; `<DECK>`, `<SKILL>` y su `<TMP>`; su
  89. archivo y prefijo; cuál de `assets/ejemplos/` se parece más a su bloque (solo uno, para calibrar el acabado); el
  90. texto exacto de sus slides; las cifras permitidas con fuente; y el vocabulario visual
  91. compartido cuando dos bloques dibujan lo mismo (por ejemplo: "portátil = pantalla trapezoidal + base en línea;
  92. paquete = rectángulo de 28 x 16"). Si no hay subagentes, construye los bloques tú mismo, uno tras otro, con el
  93. mismo brief.
  94. Como el usuario mira en vivo y el entregable sigue a las partes, cada bloque debe reemplazar sus pendientes pronto:
  95. una primera versión completa del archivo en los primeros minutos (mismos ids del guion) y después mejoras, cada una
  96. como edición puntual del fragmento que cambia. Si el usuario comenta una slide mientras se construye, reenvíale el
  97. comentario al subagente de ese bloque. Si el usuario editó a mano con el editor, sus cambios ya están en `parts/`:
  98. quien toque ese archivo después lo relee antes de escribir y no los pisa.
  99. Comprueba el avance real, no lo supongas: cuando termine cada subagente (y si el usuario pregunta), consulta
  100. `/__vivo/estado` y confirma que `entregable.listas` subió y que `entregable.hora` es reciente. Si `vivo.py` no está
  101. corriendo, corre `build.py "<DECK>"` tras cada bloque terminado: también reescribe el entregable.
  102. Un bloque tarda entre 15 y 25 minutos. Mientras tanto, cuando el usuario pregunte, responde con el estado real
  103. de cada bloque (si su archivo ya existe o cuándo se modificó por última vez) y un estimado honesto.
  104. ### 6. Ensamblar y verificar
  105. ```bash
  106. python -I "<SKILL>/scripts/build.py" "<DECK>" --out "<TMP>/deck.html" # OK, ENTREGABLE y sin AVISO
  107. node "<SKILL>/scripts/shot.mjs" "<TMP>/deck.html" "<TMP>/shots/s" cambiadas 3000 # solo slides nuevas o cambiadas
  108. python "<SKILL>/scripts/hoja.py" "<TMP>/shots" s --solo <CAPTURADAS> # hoja de solo esas, de 6 en 6
  109. STEPS=0-5 node "<SKILL>/scripts/shot.mjs" "<TMP>/deck.html" "<TMP>/shots/s" <n> # cada paso: s-<n>-p0..p5.png
  110. python "<SKILL>/scripts/hoja.py" "<TMP>/shots" s-<n>-p # hoja de esos pasos
  111. node "<SKILL>/scripts/nav.mjs" "<TMP>/deck.html" # todo adelante y atrás
  112. LIVE=1 node "<SKILL>/scripts/shot.mjs" "<TMP>/deck.html" "<TMP>/shots/live" <i> 3300 # i = un interstitial
  113. ```
  114. `shot.mjs ... cambiadas` compara las huellas de cada slide con las de la última captura con ese prefijo: la primera
  115. vez captura todas y después solo las que cambiaron; imprime `CAPTURADAS 3,7` (pásalo a `hoja.py --solo`) o
  116. `SIN CAMBIOS`. Así una corrección se revisa mirando una hoja, no el deck entero otra vez. `nav.mjs` recorre todo y
  117. solo imprime las pulsaciones atascadas y un resumen (`--detalle` para ver cada una); así se prueba lo que las capturas
  118. no ven: retroceder dentro de una slide con pasos y llegar a ella desde la siguiente. Con `LIVE=1` la captura debe
  119. mostrar ya la slide que sigue al interstitial.
  120. Mira las hojas (6 slides por imagen) y abre a tamaño completo solo lo dudoso. Busca: textos encimados o cortados,
  121. ilustraciones chicas que dejan media slide vacía, más de un foco de acento, viñetas que parecen guiones largos, cifras
  122. sin fuente, y errores de JavaScript (deben ser cero). Corrige tú lo pequeño con ediciones puntuales; si un bloque
  123. necesita rehacerse, devuélveselo a su subagente con la lista concreta.
  124. ### 7. Miniaturas de la galería
  125. El motor trae una galería para saltar a cualquier slide, como el modo presentador de PowerPoint: tecla G o el botón
  126. DIAPOSITIVAS que aparece abajo a la izquierda al mover el mouse; tiene buscador por título o número, se navega con
  127. flechas y Enter, y Esc la cierra. La galería siempre muestra miniatura: si una slide no tiene imagen generada, dibuja
  128. una copia viva de la slide en su estado final. En el HTML que se entrega las miniaturas deben ser imágenes reales
  129. (son fieles con canvas y contadores): genéralas con un solo comando (sin -I, porque usa Pillow) y vuelve a ensamblar.
  130. ```bash
  131. python "<SKILL>/scripts/miniaturas.py" "<DECK>" # rehace solo las miniaturas de slides nuevas o cambiadas
  132. ```
  133. `miniaturas.py` anota en `<DECK>/miniaturas/huellas.json` con qué versión de cada slide hizo su imagen; la siguiente
  134. vez solo captura las que cambiaron y, si no cambió ninguna, ni abre el navegador (`--todas` las rehace todas).
  135. `build.py --final` no da por terminado el deck si alguna miniatura falta o no está al día, así que córrelo de nuevo
  136. cada vez que cambien slides (también después de que el usuario edite con el editor).
  137. ### 8. Entregar
  138. El entregable ya está escrito y al día. `build.py "<DECK>" --final` lo vuelve a armar y comprueba que esté
  139. terminado: sin avisos, sin slides pendientes y con las miniaturas al día. Solo entonces imprime `FINAL <ruta>`; si
  140. no, lista lo que falta. El HTML entregable no lleva la barra en vivo ni el editor. Antes de cerrar, detén `vivo.py`
  141. (la tarea en segundo plano) y comprueba que su puerto quedó libre. Entrégalo y resume en pocas líneas: cuántas
  142. slides, qué tiene de especial, cómo se navega (incluida la galería con G), qué se verificó y qué no (por ejemplo,
  143. que no se probó en el proyector).
  144. Para compartir, el `.html` basta. Si el usuario quiere PDF o PowerPoint:
  145. ```bash
  146. python "<SKILL>/scripts/exportar.py" "<DECK>" --formato ambos # pdf | pptx | ambos; --pasos: una página por paso
  147. ```
  148. Quedan junto al HTML con el mismo nombre. Cada slide sale como imagen fiel al diseño, en su estado final (las slides
  149. con pasos, en su último paso). Las animaciones no viajan a PDF ni a PowerPoint, y los textos del PowerPoint no son
  150. editables: dilo al entregar.
  151. ## Cambios después
  152. Edita solo el fragmento que cambia en la parte que corresponda en `parts/` (no reescribas el archivo), vuelve a
  153. ensamblar con `--out "<TMP>/deck.html"` (eso ya actualiza el entregable) y revisa con `shot.mjs ... cambiadas`, que
  154. captura solo las slides tocadas. Para retoques de posición, tamaño o texto, levanta `vivo.py` y deja que el usuario
  155. los haga con el editor; luego cierra con `miniaturas.py` y `--final`. Para
  156. insertar slides entre bloques usa un prefijo intermedio (`03b-...`). Si la parte ya no existe porque la presentación
  157. se hizo sin esta carpeta, reconstruye solo lo necesario y guarda las fuentes en `fuente-presentacion/`.
  158. ## Gasto de tokens: tocar y revisar solo lo que cambió
  159. Ensamblar, reconstruir la vista en vivo, reescribir el entregable y capturar pasan en la computadora y no gastan
  160. tokens. Lo que sí gasta es lo que el modelo escribe, lee y mira. Por eso:
  161. - Cada parte se escribe completa una sola vez (la primera versión). Después, cada mejora o corrección es una edición
  162. puntual del fragmento que cambia; nunca se reescribe un archivo entero para cambiar una slide o un color.
  163. - Leer solo lo necesario: `brief.md`, `motor.md`, `deck.json` y un ejemplo. Nadie lee `shell.html` ni
  164. `cliente.js` completos (`motor.md` documenta lo que hace falta) y quien orquesta no relee las partes de los
  165. subagentes: las revisa en las hojas de capturas.
  166. - Revisar con `shot.mjs ... cambiadas` y `hoja.py --solo`: después de una corrección se mira una hoja con lo que
  167. cambió, no el deck entero. Las hojas (6 slides por imagen) cuestan mucho menos que abrir cada captura.
  168. - `nav.mjs` sin `--detalle` y `build.py` imprimen solo resúmenes y problemas; no pidas más salida de la necesaria.
  169. - Para saber el avance basta `/__vivo/estado`; no hace falta capturar ni leer archivos.
  170. - Como máximo dos rondas de corrección por bloque, salvo que algo siga roto.
  171. ## Reglas de contenido (valen para toda la presentación)
  172. - Español con tildes, eñes y signos de apertura. Si el público habla otro idioma, la presentación va en ese idioma;
  173. las respuestas al usuario, en el idioma en que escribe.
  174. - Sin guion largo, guion medio ni punto medio (el guion normal sí) y sin emojis: se ven mal proyectados y en otras
  175. fuentes. `build.py` y el editor lo revisan.
  176. - Solo cifras verificadas, cada una con su fuente en la slide. Formato numérico del público; por defecto es-CO
  177. (coma decimal y punto de miles), que es el que usa `Deck.fmt`.
  178. - Poco texto: una idea por slide, título corto, 3 o 4 puntos como máximo.
  179. - Etiqueta superior de cada slide sin numeración ni separadores tipo "//"; portada sin subtítulos de relleno.
  180. - Los motion graphics son elementos visuales (ilustraciones que explican), no texto que se mueve. El texto entra
  181. una vez y se queda quieto.
  182. - Los archivos de la presentación no mencionan cómo se hicieron: ni asistentes de IA ni esta skill.
  183. - Temas delicados (seguridad informática, salud, finanzas): divulgación conceptual, nunca instructivo ni consejo
  184. personal. Las slides de ejemplos o datos inventados llevan una etiqueta visible "ILUSTRACIÓN" o "SIMULACIÓN".
  185. ## Lecciones aprendidas
  186. - **Temas de ataques: conceptuales desde el principio.** Las ilustraciones conceptuales funcionan bien: un tubo
  187. transparente donde se lee un mensaje, un intermediario que lo desvía, un cursor que recorre etapas genéricas,
  188. todas con el nombre del ataque abajo. Las simulaciones de herramientas reales (listados de escaneo, capturas de
  189. tráfico con nombres de programas, comandos) se bloquean por seguridad. Si un subagente o una respuesta se
  190. bloquea, no lo reformules para reintentar: díselo al usuario y sigue con el resto.
  191. - **PowerPoint no conserva estas animaciones.** Rehacer las slides con formas nativas de PowerPoint quedó pobre.
  192. Por eso `exportar.py` mete cada slide como imagen fiel. Si piden que el PowerPoint conserve el movimiento, la única
  193. forma fiel es grabar cada slide como video y meterlo con reproducción automática.
  194. - **Explicar paso a paso** (un proceso, un mecanismo, cómo viaja algo de un lugar a otro) es lo que más ayuda al
  195. público: úsalo en las slides de proceso. Patrón en `references/motor.md` y ejemplos en `assets/ejemplos/`.
  196. - **Cada tema pide su estilo.** El mismo deck oscuro y rojo para todo cansa y no le queda a una clase de cocina ni
  197. a una charla de salud. Elige el estilo por lo que se va a dibujar y por el público.
  198. - **Las capturas mandan.** Varias fallas solo se vieron en las capturas: íconos diminutos que dejaban media slide
  199. vacía, una silueta que se salía de su recuadro, una palabra sola en una segunda línea.
  200. - **Un solo servidor, y solo local.** `vivo.py` escucha únicamente en 127.0.0.1 y pide un token para guardar; nada
  201. más se levanta. Apágalo al terminar: una sesión anterior dejó un servidor abierto a la red sin que nadie lo
  202. notara. Nada de recursos remotos en el deck.
  203. - **El usuario quiere ver el avance, no el resultado de golpe.** Por eso la vista en vivo arranca antes de construir
  204. y las slides pendientes muestran el plan completo desde el primer minuto.
  205. - **El entregable también va al día.** En una presentación el HTML entregable no apareció hasta el final y el usuario
  206. no pudo revisar nada antes. Ahora `esqueleto.py` lo escribe al empezar y `vivo.py` y `build.py` lo reescriben en
  207. cada avance; `--final` solo comprueba que quedó terminado.
  208. - **Reescribir todo gasta mucho.** Reescribir partes completas, releer archivos grandes y volver a mirar todas las
  209. capturas tras cada corrección disparó el consumo de tokens. Se edita y se revisa solo lo que cambió.
README.md · README · 195 lines
  1. <p align="center">
  2. <img src="docs/banner.svg" alt="Presentaciones con motion graphics, en el estilo de cada tema" width="100%">
  3. </p>
  4. <p align="center">
  5. <b>Le dices el tema y te entrega una presentación en un solo HTML, con ilustraciones animadas, que pasas con las flechas.</b>
  6. </p>
  7. ## Qué es
  8. `presentaciones-motion` es una skill para Claude Code. Le pides una presentación (tema, público, duración) y arma
  9. el guion, verifica las cifras en fuentes reales, elige un estilo que le quede al tema y construye las slides en
  10. paralelo. Mientras trabaja ves el avance en vivo, y el HTML que vas a entregar existe desde el primer minuto y se
  11. actualiza con cada slide que queda lista.
  12. Sirve para una clase, una charla, una propuesta de negocio o un taller. Cada slide lleva una ilustración animada
  13. que explica la idea (SVG, CSS o canvas): lo que se mueve es el dibujo, no el texto. Entre secciones hay
  14. transiciones de puro movimiento, y los procesos se explican paso a paso: cada flecha avanza un paso y también se
  15. puede retroceder.
  16. ## Así se ve
  17. Tres presentaciones de ejemplo, cada una en el estilo que le queda a su tema. Todas salieron de esta skill.
  18. <table>
  19. <tr>
  20. <td width="50%"><img src="docs/cafe-portada.gif" alt="Portada ilustrada en estilo Papel" width="100%"></td>
  21. <td width="50%"><img src="docs/cafe-proceso.gif" alt="Proceso del café explicado paso a paso" width="100%"></td>
  22. </tr>
  23. <tr>
  24. <td colspan="2"><b>Estilo Papel.</b> Una clase de cocina: portada ilustrada y el recorrido del grano a la taza, un paso por flecha.</td>
  25. </tr>
  26. <tr>
  27. <td><img src="docs/luz-red.gif" alt="Diagrama animado de la red eléctrica en estilo Plano técnico" width="100%"></td>
  28. <td><img src="docs/luz-tension.gif" alt="Transformadores explicados paso a paso" width="100%"></td>
  29. </tr>
  30. <tr>
  31. <td colspan="2"><b>Estilo Plano técnico.</b> Cómo llega la luz a tu casa: un diagrama con energía que circula y la tensión que baja por etapas.</td>
  32. </tr>
  33. <tr>
  34. <td><img src="docs/vacuna-pasos.gif" alt="Cómo una vacuna entrena al cuerpo, paso a paso, en estilo Clínico" width="100%"></td>
  35. <td><img src="docs/vacuna-respuesta.gif" alt="Gráfica de la respuesta inmune que se dibuja al entrar" width="100%"></td>
  36. </tr>
  37. <tr>
  38. <td colspan="2"><b>Estilo Clínico.</b> Divulgación de salud: una ilustración conceptual por pasos y una gráfica que se dibuja sola.</td>
  39. </tr>
  40. <tr>
  41. <td><img src="docs/i-circuito.gif" alt="Transición de puro movimiento con pistas de circuito" width="100%"></td>
  42. <td><img src="docs/i-celulas.gif" alt="Transición de puro movimiento con células que se dividen" width="100%"></td>
  43. </tr>
  44. <tr>
  45. <td colspan="2"><b>Interstitials.</b> Transiciones de puro movimiento entre secciones, sin texto.</td>
  46. </tr>
  47. </table>
  48. ## Vista en vivo y editor tipo PowerPoint
  49. <p align="center">
  50. <img src="docs/vivo.gif" alt="La vista en vivo reemplaza las slides pendientes en cuanto quedan listas" width="100%">
  51. </p>
  52. Mientras se construye, la presentación se abre en tu navegador desde un servidor local y se recarga sola con cada
  53. cambio, en la misma slide donde estabas. Las slides que faltan aparecen como "EN CONSTRUCCIÓN" desde el principio,
  54. así ves el plan completo y lo corriges antes de que esté terminado.
  55. <p align="center">
  56. <img src="docs/editor.gif" alt="Editor tipo PowerPoint: seleccionar y mover un elemento con guías" width="100%">
  57. </p>
  58. Con la tecla **E** se abre el editor: panel de slides con miniaturas, cinta de herramientas y panel de propiedades.
  59. - Seleccionar uno o varios elementos, moverlos con guías, escalar y rotar con manijas.
  60. - Alinear y distribuir, traer al frente o enviar al fondo.
  61. - Copiar, cortar, pegar y duplicar, también entre slides.
  62. - Insertar texto, rectángulos, círculos, líneas e imágenes (desde archivo, pegadas o arrastradas).
  63. - Cambiar color, tamaño de letra, negrita, cursiva, opacidad y capas.
  64. - Deshacer y rehacer. Al guardar (Ctrl+S) todo queda en los archivos fuente, con respaldo y "Deshacer guardado".
  65. ## Qué incluye
  66. - **Un solo archivo.** Fuentes e imágenes van adentro: funciona sin internet y abre en cualquier navegador. Para
  67. compartir la presentación basta mandar el `.html`.
  68. - **Hecho para presentar.** Flechas, espacio o clic para avanzar; **F** pantalla completa; **B** pantalla negra;
  69. **G** galería de miniaturas para saltar a cualquier slide.
  70. - **Escenario fijo de 1920 x 1080** que se escala a cualquier pantalla o proyector.
  71. - **Un estilo para cada tema.** Siete estilos con contraste revisado (Papel, Plano técnico, Clínico, Corporativo,
  72. Pizarra, Atardecer y Cartel) o la paleta de tu marca o tu escuela.
  73. - **Entregable siempre al día.** El HTML final existe desde el inicio y se reescribe con cada avance.
  74. - **Exporta a PDF y PowerPoint.** Cada slide sale como imagen fiel al diseño; las animaciones se quedan en el HTML.
  75. - **Se revisa sola.** Captura cada slide con Edge o Chrome sin ventana, recorre la navegación hacia adelante y
  76. hacia atrás y cuenta los errores de JavaScript. Después de una corrección solo vuelve a capturar lo que cambió.
  77. - **Reglas de contenido.** Cifras verificadas y con su fuente en la slide, poco texto, una idea por slide, y los
  78. temas delicados (salud, finanzas, seguridad) como divulgación, nunca como instructivo.
  79. ## Cómo trabaja
  80. ```mermaid
  81. flowchart LR
  82. A[Encargo] --> B[Cifras verificadas]
  83. B --> C[Estilo]
  84. C --> D[Guion]
  85. D --> E[Slides pendientes y entregable]
  86. E --> F[Bloques en paralelo]
  87. F --> G[Revisión con capturas]
  88. G --> H[Miniaturas]
  89. H --> I[Entrega]
  90. E -. vista en vivo .-> V((Tú))
  91. F -. cada guardado .-> V
  92. ```
  93. 1. **Encargo.** Tema, público, duración y tono. Si ya tienes la lista de temas, la respeta en su orden.
  94. 2. **Cifras.** Cada número que va a pantalla se verifica en la web y se anota con su fuente.
  95. 3. **Estilo.** Elige paleta y fuentes según el tema, el público y el lugar donde se va a presentar.
  96. 4. **Guion.** Slides agrupadas en bloques de 4 a 6, con el visual de cada una.
  97. 5. **Esqueleto.** Crea todas las slides como pendientes, escribe el HTML entregable y abre la vista en vivo.
  98. 6. **Bloques en paralelo.** Cada bloque lo construye un agente distinto; cada slide terminada reemplaza a su
  99. pendiente en la vista y en el entregable.
  100. 7. **Revisión.** Capturas de cada slide, cada paso y la navegación completa.
  101. 8. **Entrega.** Miniaturas de la galería y comprobación final: sin pendientes, sin avisos y sin errores.
  102. ## Requisitos
  103. - Claude Code (app de escritorio o terminal).
  104. - Python 3.10 o más nuevo, con Pillow.
  105. - Node.js 22 o más nuevo.
  106. - Microsoft Edge o Google Chrome.
  107. - Windows 10 u 11 para la fuente de cuerpo por defecto, Bahnschrift, que viene con Windows y no se incluye aquí.
  108. En Mac o Linux la skill la cambia por una fuente libre.
  109. ## Instalación
  110. ```bash
  111. git clone https://github.com/MarioUrenaGarcia/presentaciones-motion.git ~/.claude/skills/presentaciones-motion
  112. pip install pillow
  113. ```
  114. En Windows con PowerShell:
  115. ```powershell
  116. git clone https://github.com/MarioUrenaGarcia/presentaciones-motion.git "$env:USERPROFILE\.claude\skills\presentaciones-motion"
  117. pip install pillow
  118. ```
  119. Reinicia Claude Code. Para actualizar a la última versión:
  120. ```bash
  121. git -C ~/.claude/skills/presentaciones-motion pull
  122. ```
  123. ## Úsala
  124. Pídele algo como:
  125. - "Una clase de 10 slides sobre el ciclo del agua para niños de primaria."
  126. - "Una charla de 15 minutos sobre finanzas personales para estudiantes universitarios."
  127. - "La presentación de resultados del trimestre con los colores de mi empresa: azul #1f4e9c y gris."
  128. - "Agrega una slide que explique paso a paso cómo se hace una transferencia bancaria."
  129. - "Exporta la presentación a PDF y PowerPoint."
  130. Te muestra el guion, abre la vista en vivo y te da la ruta del HTML. Al terminar te dice cuántas slides tiene, qué
  131. se verificó y qué no.
  132. ## Estructura
  133. ```
  134. SKILL.md flujo completo y reglas
  135. references/brief.md instrucciones para quien construye cada bloque
  136. references/motor.md API del motor de slides
  137. references/estilos.md estilos y reglas de color
  138. assets/shell.html motor: escenario, navegación, pasos y galería
  139. assets/vivo/cliente.js vista en vivo y editor
  140. assets/ejemplos/ bloques de ejemplo: portada ilustrada, diagramas, pasos y gráficas
  141. assets/fonts/ Bebas Neue y su licencia
  142. scripts/build.py arma el HTML de un solo archivo
  143. scripts/esqueleto.py slides pendientes a partir del guion
  144. scripts/vivo.py servidor local de la vista en vivo y el editor
  145. scripts/shot.mjs capturas con Edge o Chrome sin ventana
  146. scripts/hoja.py hojas de contacto para revisar varias capturas a la vez
  147. scripts/nav.mjs prueba la navegación hacia adelante y hacia atrás
  148. scripts/recorrido.mjs recorre el deck como el presentador
  149. scripts/miniaturas.py miniaturas de la galería
  150. scripts/exportar.py PDF y PowerPoint
  151. scripts/cdp.mjs control del navegador para capturas y pruebas
  152. docs/ imágenes de este README
  153. ```
  154. ## Seguridad
  155. - El servidor de la vista en vivo escucha solo en `127.0.0.1` y pide un token para guardar.
  156. - El HTML no carga nada de internet.
  157. ## Licencia
  158. El código está bajo la licencia MIT (`LICENSE`). Bebas Neue, de Dharma Type, se distribuye bajo la SIL Open Font
  159. License 1.1 (`assets/fonts/OFL-BebasNeue.txt`). Bahnschrift es de Microsoft y no se incluye.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.