Communitygithub.com

Implémentation des animations Figma

Traduit les animations et transitions Figma en code de production prêt à l'emploi. À utiliser lors de l'implémentation d'animations à partir d'un design Figma — quand l'utilisateur mentionne 'implémenter ce mouvement', 'ajouter une animation depuis Figma', 'animer ce composant', fournit une URL Figma dont le nœud est animé, ou quand `get_design_context` renvoie des données de mouvement ou vous demande d'appeler `get_motion_context`.

Qu'est-ce que Implémentation des animations Figma ?

Cette compétence permet de traduire les animations et transitions Figma en code exécutable pour les applications. Elle utilise deux outils clés : `get_motion_context`, la source de vérité pour les données d'animation (images clés, easing, code pré-généré), et `get_design_context`, qui fournit la structure statique du design. Le flux de travail consiste à récupérer le contexte statique, à obtenir les données d'animation via `get_motion_context`, puis à fusionner les deux en faisant correspondre les identifiants de nœuds. Le résultat est adapté à la stack technique de l'utilisateur (React avec motion.dev, CSS pur, ou autres bibliothèques). Les limites incluent la non-création d'animations dans Figma et la couverture uniquement des animations de base, pas des flux interactifs complexes.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Devin-AXIS/iPolloWork/tree/HEAD/examples/plugin-packages/figma/skills/figma-implement-motion

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Implémenter le mouvement

Présentation

Cette compétence guide la traduction des animations et transitions Figma en code exécutable (motion.dev, images clés CSS, ou bibliothèques spécifiques au framework).

Figma expose le mouvement via deux outils :

  • get_motion_context — outil de mouvement autoritaire. Renvoie l'inventaire complet des nœuds animés, des extraits de code précalculés (CSS @keyframes + motion.dev), des liaisons d'images clés de secours lorsque les extraits ne sont pas disponibles, et des indices de coordination de chronologie récursive (timelineCohorts). Source de vérité pour les données d'animation et les identifiants de nœuds qui animent.
  • get_design_context — la structure du design : disposition, dimensions, ressources, style, indices Code Connect, contexte de capture d'écran, et parfois des marqueurs de placement de mouvement sur les éléments animés (data-node-id, et sur les nœuds divisés data-motion-keys / data-motion-wrapper-for / data-motion-transform-template). Il peut rendre un nœud animé comme un élément simple (div, p, span, etc.) ou un élément de mouvement (motion.div) ; il n'intègre pas les valeurs d'animation.

Les deux sont liés par l'identifiant de nœud, et c'est tout le flux de travail. get_motion_context vous indique quels nœuds animent et donne les valeurs d'images clés, l'easing, le timing et les extraits. get_design_context vous indique à quoi ressemblent ces nœuds et où ils se trouvent. Pour chaque nœud dans get_motion_context.nodes, trouvez le data-node-id correspondant dans le contexte de design et fusionnez le mouvement dans cette structure — en ajoutant ou en enveloppant un motion.{tag} lorsque l'élément structurel est simple. Lorsque le contexte de design a réutilisé un composant Figma, le nœud de mouvement peut également inclure fallbackNodeId ; utilisez-le uniquement comme solution de secours après avoir essayé le nodeId exact.

Limites de la compétence

  • Utilisez cette compétence lorsque le livrable est du code de mouvement dans le dépôt de l'utilisateur.
  • Si l'utilisateur demande de créer/modifier des animations dans Figma lui-même, passez à figma-use et suivez cette compétence à la place.
  • Cette compétence couvre actuellement les animations telles qu'émises par get_motion_context (extraits plus pistes d'images clés de secours, y compris le mouvement provenant de préréglages résolu dans ces formes). Les flux de variantes interactives plus larges peuvent encore nécessiter une gestion d'état spécifique au produit dans le code.

Prérequis

  • Serveur MCP Figma connecté et accessible.
  • Identifiant de nœud extrait de l'URL Figma fournie par l'utilisateur. Format d'URL : https://figma.com/design/:fileKey/:fileName?node-id=1-2 — extrayez fileKey (le segment après /design/) et nodeId (la valeur du paramètre de requête node-id, par exemple 42-15).
  • Base de code cible. Le format de sortie du mouvement s'adapte à la stack (voir Recommandations framework).

Choix de l'outil

Pour l'implémentation du mouvement, utilisez les deux outils avec des rôles distincts :

SituationOutilPourquoi
Comprendre la structure statique, les ressources, les styles, Code Connect ou la disposition visuelleget_design_contextDonne la référence de code du composant/page et les URL des ressources nécessaires pour placer correctement les nœuds animés.
Récupérer les données d'animation pour n'importe quel nœudget_motion_contextConçu spécialement pour le mouvement et la source de vérité pour le timing, l'easing, les extraits et les images clés.
Un nœud a des marqueurs de mouvement (data-motion-keys, data-motion-wrapper-for)Marqueurs pour le placement divisé, get_motion_context pour les valeursLes marqueurs de division vous indiquent quelles pistes vont sur quel élément ; les images clés/easing/timing et l'inventaire des nœuds animés proviennent de get_motion_context.

get_motion_context accepte recursive: true (limité à 500 nœuds) lorsque vous avez besoin du mouvement des descendants en un seul appel.

Flux de travail requis

Étape 1 : Confirmer la disponibilité du contexte de design statique

get_design_context(fileKey=":fileKey", nodeId="<node-id>")

Si get_design_context a déjà été appelé pour ce nœud, réutilisez cette sortie. Sinon, appelez-le normalement maintenant.

Utilisez-le comme la structure de référence — hiérarchie, dimensions, style, ressources, indices Code Connect, contexte de capture d'écran, et tous les marqueurs de placement de mouvement qu'il contient éventuellement (Étape 3). L'inventaire des nœuds animés et les valeurs d'animation proviennent de get_motion_context (Étape 2).

Étape 2 : Récupérer les données de mouvement autoritaires

get_motion_context(fileKey=":fileKey", nodeId="<node-id>", recursive=true)

Forme de la réponse (une entrée par nœud animé) :

  • codeSnippets — chaînes CSS @keyframes et motion.dev pré-générées. Utilisez-les directement. Ne les régénérez pas à partir des données de piste de secours.
  • keyframeBindings — pistes d'images clés liées, y compris le mouvement dérivé de préréglages résolu en données de piste, incluses uniquement comme données de secours lorsque les deux formats d'extraits sont absents.
  • motionSummary — description en langage naturel d'une ligne par champ de l'animation. Présent uniquement lorsqu'il n'y a pas d'extrait (le codegen de mouvement uniquement par liaisons d'images clés ne peut pas être exprimé en CSS/motion.dev). Construisez à partir de celui-ci lorsqu'il est présent ; ignorez-le chaque fois qu'un extrait existe.
  • fallbackNodeId — identifiant de secours optionnel pour faire correspondre le contexte de design composantisé. Si nodeId est un identifiant qualifié d'instance tel que I4005:6111;30:8005, D2R peut rendre le corps du composant réutilisable avec l'identifiant du composant sous-jacent à la place, comme 4002:3957. Dans ce cas, fallbackNodeId est le data-node-id à rechercher si la recherche exacte de nodeId échoue.

Les réponses récursives incluent également timelineCohorts — un tableau de niveau supérieur (pas par nœud) de nœuds partageant une seule chronologie : { rootNodeId, durationMs, loopMode: 'once' | 'loop' | 'boomerang', memberNodeIds[] }. Pour un mouvement multi-nœuds coordonné, pilotez tous les memberNodeIds à partir d'un cycle de vie partagé en utilisant durationMs (÷1000 pour les secondes) et loopMode — n'inférez pas le timing à partir de l'ordre des frères.

Détails d'implémentation importants pour les LLM :

  • Lorsqu'un extrait existe, motionSummary, timelineDurationMs et transformOrigin peuvent être omis pour réduire la charge utile — l'extrait contient déjà la durée + l'origine de transformation (motion.dev duration / style={{ transformOrigin }}, ou CSS animation / transform-origin) et la cohorte contient durationMs. Un champ manquant ne signifie jamais « pas d'animation ».
  • Les réponses récursives dédoublonnent les extraits identiques en double. Un extrait peut être remplacé par un commentaire pointant vers le premier nœud avec un mouvement identique ; réutilisez le même composant, variante, classe ou constantes au lieu d'écrire une seconde animation.
  • Le serveur MCP déduit les extraits CSS vs motion.dev de clientFrameworks ; si la réponse ne contient qu'un seul format d'extrait, adaptez ce format à la stack de l'utilisateur plutôt que de supposer que l'autre format a échoué.

Étape 3 : Fusionner les contextes statique et de mouvement

  • Commencez par get_motion_context.nodes, et non par les balises motion.* visibles dans le JSX statique. Chaque nœud retourné est animé. Faites correspondre chaque nœud de mouvement au get_design_context d'abord par nodeId / data-node-id exact. Si et seulement s'il n'y a pas de correspondance exacte, essayez fallbackNodeId / data-node-id. Revenez au nom/type de nœud et à la position de la capture d'écran uniquement après l'échec des deux identifiants.
  • La correspondance exacte d'identifiant l'emporte sur fallbackNodeId. fallbackNodeId pointe vers l'identifiant du composant sous-jacent que D2R peut émettre à l'intérieur d'un composant réutilisable. Il est partagé par chaque instance de ce composant. Si le nodeId exact existe dans le contexte de design, appliquez le mouvement là-bas et ignorez la solution de secours. Ceci est crucial pour l'animation d'instance racine : une instance peut tourner ou se déplacer différemment d'une autre instance du même composant, et appliquer ce mouvement au corps du composant partagé animerait toutes les instances de manière incorrecte.
  • Appliquez chaque nœud de mouvement à la structure de contexte de design correspondante, indexée par data-node-id. Le data-node-id correspondant est l'ancre structurelle, pas toujours l'élément DOM final qui reçoit le mouvement. Utilisez la forme de l'extrait et les marqueurs de placement pour décider si le mouvement va sur cet élément exact, un emballage, un élément intérieur ou un chemin SVG en ligne. get_design_context peut déjà émettre motion.{tag} avec des valeurs supprimées, ou il peut émettre un élément structurel simple (div, p, span, racine de composant, etc.). S'il est simple et que l'extrait cible l'élément lui-même, convertissez-le en motion.{tag} approprié ou ajoutez un emballage de mouvement tout en préservant le texte, les enfants, les classes/styles, les attributs et le data-node-id du nœud. Chargez references/examples-and-anti-examples.md pour voir des exemples de cette étape de fusion.
  • Le mouvement d'enfant composantisé correspond généralement par solution de secours. Lorsque le contexte de design extrait une instance Figma dans un composant React réutilisable, les enfants à l'intérieur de ce corps de composant ont souvent des identifiants de composant sous-jacents (4002:3957) tandis que le contexte de mouvement signale des identifiants d'instance en direct (I4005:6111;30:8005). Dans ce cas, utilisez fallbackNodeId pour trouver le data-node-id du corps du composant, mais gardez le mouvement limité à l'instance rendue que vous implémentez. S'il y a plusieurs instances et qu'une seule a un mouvement racine différent, la correspondance exacte d'identifiant maintient ce mouvement par instance séparé.
  • Les nœuds divisés portent un marqueur data-motion-keys / data-motion-wrapper-for — voir Gestion des transformations entrelacées ci-dessous.
  • Préservez les emballages display: contents — sauf si le groupe lui-même anime. Les emballages de groupe transparents en termes de disposition arrivent sous forme de contents (Tailwind contents), généralement accompagnés d'un absolute/inset-[…] mort (ceux-ci ne font rien sur une boîte contents). Pour un groupe statique, gardez display: contents et laissez les enfants se positionner par rapport au véritable ancêtre le plus proche — convertir le inset de l'emballage en une boîte positionnée repositionne les enfants dans une boîte plus petite, donc ils s'affichent trop petits/décalés vers l'intérieur. Pour un groupe animé (le nœud du groupe lui-même a un mouvement), display: contents ne peut pas porter de transformation — remplacez-le par un véritable emballage positionné et appliquez le mouvement du groupe là-bas. Chargez references/gotchas.md avant d'implémenter ce cas.
  • get_motion_context est l'inventaire complet des nœuds animés. Certains nœuds animés s'affichent comme des éléments simples (non motion) — racines d'instance de composant (<div> de positionnement simple), texte (<p>), masques — qui portent toujours un data-node-id. Parcourez chaque nœud dans la réponse de mouvement et appliquez son mouvement à l'élément avec le data-node-id correspondant, en enveloppant ou convertissant si nécessaire. Si un nœud animé n'a aucun élément du tout dans la sortie (par exemple, un masque animé aplati dans un mask-image statique), ne le supprimez pas silencieusement — laissez un commentaire // TODO: <nodeId> motion unsupported et signalez-le dans votre résumé.
  • Si un nœud apparaît dans le contexte de mouvement mais pas dans le JSX statique, ajoutez l'élément nécessaire pour le représenter — le code du contexte de design est une référence, pas un inventaire d'animation complet.
  • En cas de conflit entre le contexte de design et celui de mouvement (timing/easing/valeurs animées), préférez get_motion_context.
  • Mouvement SVG au niveau du chemin : inlinez le SVG et animez le vrai <path>. Lorsque get_motion_context cible le chemin d'un vecteur (PATH_TRIM, motion.path, stroke-dasharray) mais que le contexte de design le rend comme une <img>, inlinez le SVG et appliquez l'extrait au <path>, en gardant l'emballage de disposition. Chargez references/svg-and-path-motion.md pour le guide complet de ce cas (motion.path, pathLength="1", superposition emballage+chemin, découpage de chemin CSS).

Gestion des transformations entrelacées

Un nœud avec à la fois une transformation de base statique et des transformations animées est divisé en éléments imbriqués afin que les deux se composent correctement au lieu de se battre : un motion.div sans identifiant portant data-motion-wrapper-for="<nodeId>" (l'emballage EXTÉRIEUR) enveloppe une div de transformation statique (par exemple rotate-45 + dimensionnement hypot() — ou l'emballage lui-même porte data-motion-transform-template="<css>") qui enveloppe le nœud INTÉRIEUR (data-node-id). Gardez l'imbrication emballage > div transformation statique > intérieur — l'effondrer brise le dimensionnement et la transformation de base.

  • Placez les pistes par data-motion-keys. Les data-motion-keys de l'emballage (pistes de transformation — x/y/rotate/scaleX/scaleY/skewX) vont sur l'emballage EXTÉRIEUR ; les data-motion-keys de l'élément intérieur vont sur l'élément INTÉRIEUR.
  • Réappliquez un data-motion-transform-template. Si l'emballage en porte un, définissez transformTemplate={(_, generated) => "<css> " + generated} pour que la transformation animée se compose par-dessus cette transformation de disposition statique.
  • Décalez la transformation animée par la base statique (évitez la double rotation). get_motion_context donne la transformation absolue du nœud, qui inclut déjà la base statique que ces divs appliquent. Un extrait rotate de [45, 125, 125] sur une base rotate-45 signifie que l'emballage anime le décalage [0, 80, 80] (= absolu − 45), pas l'absolu — sinon le 45° s'applique deux fois et l'élément se trouve à 90° au repos. Les pistes sans base statique (par exemple x/y commençant à 0) passent inchangées. Voir l'exemple de transformation entrelacée.
  • Gardez les transformations de disposition séparées des transformations Motion. Pour chaque élément motion.* qui anime rotate, scale ou skew, vérifiez qu'il ne repose pas également sur des transformations de disposition Tailwind telles que -translate-x-1/2 ou -translate-y-1/2 pour le centrage/positionnement. Ces utilitaires partagent la propriété CSS transform que Motion.dev écrit en ligne, donc la transformation de Motion peut effacer la translation de disposition. Si les deux sont nécessaires, divisez l'élément en un emballage de disposition statique portant la transformation de centrage/positionnement et un élément motion.* intérieur portant rotate/scale/opacity animé, ou encodez le décalage de disposition dans Motion lui-même (x: "-50%") et gardez-le présent pour chaque image clé.

Étape 4 : Appliquer le mouvement dans le code

  • motion.dev présent dans les extraits ? Utilisez le code motion.dev textuellement pour les cibles React. Importez depuis motion/react — à moins que la base de code n'utilise déjà une autre bibliothèque de mouvement (Framer Motion, React Spring, GSAP), auquel cas adaptez l'extrait à celle-ci. Chargez references/framework-recommendations.md lors de l'adaptation à une autre stack ou du choix d'une bibliothèque.
  • Images clés CSS présentes ? Utilisez pour les cibles vanilla/non-React, ou lorsque la base de code n'a pas de bibliothèque de mouvement React.
  • Pas d'extraits (uniquement liaisons d'images clés) ? Construisez l'équivalent motion.dev/CSS à partir de keyframeBindings. Les propriétés keyframeBindings incluent nodeId, property (par exemple x, y, rotate, opacity, scaleX, scaleY, backgroundColor, borderRadius, fill, stroke, stroke-dashoffset, clip-path), keyframes (tableau de valeurs), easing (par exemple ease, ease-in-out, [0.42,0,0.58,1], step-start, etc.), et timing (durationMs, delayMs, endDelayMs, direction, iterations, fillMode). Convertissez ces données en syntaxe motion.dev ou CSS. Pour les images clés CSS, utilisez les fonctions d'easing et les valeurs de timing ; pour motion.dev, utilisez la durée, le délai, l'easing et le mode de boucle. Utilisez les extraits tels quels chaque fois qu'ils existent — les keyframeBindings sont une solution de secours pour les animations que le générateur d'extraits n'a pas pu exprimer.
  • Pistes d'images clés manquantes ? Si motionSummary est présent, construisez le mouvement à partir du résumé en langage naturel. Lisez le résumé, déterminez le type d'animation (par exemple disparaître, se déplacer, pivoter), et créez une animation motion.dev ou CSS appropriée. Utilisez des valeurs d'images clés et de timing raisonnables basées sur la description. Ne générez un extrait à partir de motionSummary que si les extraits et les keyframeBindings sont tous absents.
  • Le mouvement qui disparaît ? Utilisez animate={{ opacity: [1, 0] }} pour motion.dev ou @keyframes fadeOut { from { opacity: 1; } to { opacity: 0; } } pour CSS. Utilisez fillMode: 'forwards' si l'élément doit rester caché après l'animation.
  • Aucune des options ci-dessus ? Ne créez pas d'animation — laissez un commentaire expliquant le mouvement manquant.

Si la sortie de get_motion_context inclut un champ recommended_driver :

recommended_driverSignificationAction
motionLe design utilise motion.dev/framer-motionUtilisez la syntaxe motion.dev. Voir designs de mouvement avec motion.dev
cssLe design est purement animation CSSUtilisez les images clés CSS. Voir designs de mouvement avec CSS

Étape 4.1 : Générer le code de mouvement

Designs de mouvement avec motion.dev

Lorsque le design doit être implémenté avec motion.dev ou une bibliothèque de mouvement React, générez le code comme suit :

Motion explicite : Utilisez le composant Motion explicitement et mettez les valeurs d'images clés dans l'attribut animate. Utilisez les valeurs de l'extrait motion.dev lorsque disponible.

<motion.div
  animate={{
    x: [0, 100, 50],
    y: [0, -50, 0],
    opacity: [1, 0.5, 1],
    scale: [1, 1.2, 1],
  }}
  transition={{
    duration: 2,       // diviser durationMs par 1000
    ease: "easeInOut",
    repeat: Infinity,  // si la boucle est activée
    repeatType: "mirror" // si boomerang
  }}
>
  • Extrayez les propriétés d'animation de l'extrait motion.dev existant ou des données keyframeBindings.
  • Utilisez durationMs / 1000 pour la durée. Utilisez delayMs / 1000 pour le délai.
  • Utilisez keyframes et easing pour les valeurs clés.
  • Pour les animations multi-nœuds, créez un composant d'animation partagé ou utilisez des timings coordonnés.

Animation de scroll : Si le design spécifie une animation déclenchée par le défilement, utilisez useInView ou whileInView.

<motion.div
  initial={{ opacity: 0, y: 50 }}
  whileInView={{ opacity: 1, y: 0 }}
  viewport={{ once: true, amount: 0.2 }}
>
  • Utilisez les valeurs appropriées initial et whileInView basées sur l'intention de mouvement du design.
  • Utilisez viewport={{ once: true }} pour les animations qui ne se produisent qu'une fois.

Designs de mouvement avec CSS

Lorsque le design doit être implémenté avec des animations CSS, incluez l'intégralité des images clés dans votre composant CSS/SCSS et appliquez l'animation à l'élément cible. Utilisez les extraits CSS/@keyframes directement lorsqu'ils sont disponibles.

@keyframes slideIn {
  from {
    transform: translateX(-100px);
    opacity: 0;
  }
  to {
    transform: translateX(0);
    opacity: 1;
  }
}

.animated-element {
  animation: slideIn 1s ease-out forwards;
}
  • Utilisez les extraits CSS trouvés dans codeSnippets tels quels. Ne les modifiez pas sauf si nécessaire.
  • Si aucun extrait CSS n'est présent mais que keyframeBindings existe, construisez les images clés à partir des pistes.
  • Utilisez durationMs, easing, delayMs et fillMode pour les propriétés animation.

Étape 5 : Valider et itérer

Une fois que vous avez appliqué le mouvement, validez et ajustez :

  • Vérifiez que l'animation correspond à l'intention du design (timing, easing, ordre).
  • Assurez-vous que l'animation ne casse pas la mise en page ni les fonctionnalités existantes.
  • Testez sur différentes tailles d'écran si pertinent.
  • Ajoutez des transitions/animations de repli pour les navigateurs qui ne supportent pas certaines fonctions.
  • Documentez les compromis ou les décisions prises (par exemple, remplacer une animation complexe par une version simplifiée).

Recommandations framework

Charger references/framework-recommendations.md pour des recommandations spécifiques au framework et des motifs d'adaptation entre motion.dev, Framer Motion, react-spring, GSAP, et les animations CSS pures.

Conseils pour la résolution des problèmes

Charger references/troubleshooting.md pour des problèmes courants et leurs solutions.

Exemples et contre-exemples

Charger references/examples-and-anti-examples.md pour des exemples détaillés du flux de fusion, y compris les cas particuliers et les contre-exemples.

Notes importantes

  • Consultez toujours get_motion_context comme source de vérité pour les données d'animation.
  • Préférez utiliser les extraits de code générés plutôt que de régénérer des animations à partir de zéro.
  • Lorsque des décisions de conception doivent être prises (par exemple, comment gérer un cas non pris en charge), communiquez clairement avec l'utilisateur.

Individual skills in this repo

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

Devin-AXIS/iPolloWork

Create deterministic animation and transitions for the active iPollo Video project.

Devin-AXIS/iPolloWork

Inspect, validate, preview, and render the active iPollo Video project with its bundled HyperFrames CLI.

Devin-AXIS/iPolloWork

Apply the core composition, timing, media, and determinism contract used by iPollo Video.

Devin-AXIS/iPolloWork

Plan visual direction, typography, pacing, audio, and composition for iPollo Video projects.

Devin-AXIS/iPolloWork

Build seek-safe keyframe animation for the active iPollo Video timeline.

Devin-AXIS/iPolloWork

Reuse approved HyperFrames blocks and components inside the active iPollo Video project.

Devin-AXIS/iPolloWork

Route video creation and editing through the active iPollo Video project and its built-in HyperFrames runtime.

Devin-AXIS/iPolloWork

Create or edit the active iPolloWork video's visual assets, installed recipes, editable composition and seek-safe motion; use for assembly or local picture/text/theme changes.

Devin-AXIS/iPolloWork

Add or revise music, sound effects and their mix in the active iPolloWork video, using authorized sources, real editable tracks and measured event cues.

Devin-AXIS/iPolloWork

Write or revise the active iPolloWork video's native STORYBOARD.md, with source coverage, content-led sequence and provisional timing; use for script-only work.

Devin-AXIS/iPolloWork

Route the active iPolloWork video request to its current storyboard, compose, voiceover or soundtrack work, preserving the client-owned delivery flow.

Devin-AXIS/iPolloWork

Add or revise scene-bound narration or speech-linked captions in the active iPolloWork video using actual voice settings, measured audio and alignment.

Devin-AXIS/iPolloWork

Create product launch and promotional videos through the active iPollo Video workflow.

Devin-AXIS/iPolloWork

Develop or update reusable visual components for iPolloWork Video, including maps, charts, rankings, diagrams, openings and endings. Use for component authoring rules, manifests, editable variables, shared data forms, inherited design themes, AI editing slots and seekable HyperFrames timelines. Not for producing a whole video, authoring a full-project template, or packaging a DeepSeek host plugin.

Devin-AXIS/iPolloWork

Motion / animation context for the `use_figma` MCP tool — animating Figma nodes via manual keyframes, animation styles, easing, and timeline duration. Load alongside figma-use whenever a task involves adding, editing, or inspecting animation on a node.

Devin-AXIS/iPolloWork

Plan and create short videos using the installed short-video-studio workspace app. Manage its creative canvas, scripts, storyboards, characters and local assets, generate images or video through connected Work channels, and hand off editable tracks to Work Video Studio.

Devin-AXIS/iPolloWork

Find, generate, process, and reuse media through the active iPollo Video session's media services.

Skills associés