Communitygithub.com

FerroxLabs/murage

Experiencia en animación web que cubre animaciones y transiciones CSS, Web Animations API, Framer Motion, GSAP, animaciones impulsadas por desplazamiento, animaciones de diseño, física de resortes, preferencias de movimiento reducido y presupuestos de rendimiento.

¿Qué es murage?

Este skill proporciona una guía completa para diseñar e implementar animaciones web efectivas y de alto rendimiento. Está diseñado para ayudar a desarrolladores y diseñadores a seleccionar la herramienta de animación adecuada según la complejidad de la tarea, ya sean simples transiciones CSS, animaciones de componentes con Framer Motion o secuencias temporales complejas con GSAP. Cubre principios fundamentales como la física de resortes, animaciones de diseño, gestos y animaciones impulsadas por desplazamiento, asegurando que las animaciones sean suaves (60 fps) y accesibles. También incluye pautas para respetar las preferencias de movimiento reducido del usuario y optimizar el rendimiento mediante la animación exclusiva de las propiedades 'transform' y 'opacity'. El skill es compatible con los principales frameworks y plataformas (React con Framer Motion, Vue con <Transition>, y CSS nativo), y proporciona un marco de decisión claro, fragmentos de código prácticos y una lista de verificación de arquitectura para garantizar implementaciones exitosas.

Compatible con~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/FerroxLabs/murage/tree/HEAD/skills-library/animation-designer

Preguntar en tu IA favorita

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

Documentación

Animation Designer

Propósito

Diseñar e implementar animaciones web intencionadas y de alto rendimiento que mejoren la experiencia del usuario sin sacrificar rendimiento ni accesibilidad. Este skill cubre herramientas de animación, patrones y el marco de decisión para elegir el enfoque correcto.

Selección de Herramientas de Animación

Matriz de Decisión

NECESIDAD DE ANIMACIÓN                     HERRAMIENTA RECOMENDADA
--------------------------------------------------------------
Efectos simples de hover/focus              Transiciones CSS
Secuencias de keyframes (carga, etc.)       CSS @keyframes
Animaciones de entrada/salida de componentes Framer Motion (React)
                                             Vue <Transition> (Vue)
Revelaciones activadas por desplazamiento   Animaciones CSS impulsadas por desplazamiento
                                             (o Intersection Observer)
Secuencias temporales complejas              GSAP
Animaciones de rutas SVG                     GSAP o CSS
Movimiento basado en física/resorte          Framer Motion (spring)
Animaciones de diseño (posición/tamaño)      Framer Motion (layoutId)
Animaciones basadas en gestos (arrastrar, pellizcar) Framer Motion (drag)
Transiciones de elementos compartidos        View Transitions API
Animaciones de visualización de datos        Transiciones D3 o GSAP
Micro-interacciones (iconos, interruptores)  CSS o Lottie

Transiciones CSS

Fundamentos

/* Atajo de transición: propiedad duración función-de-temporización retraso */
.button {
  background: var(--color-marca);
  transition: background 200ms ease-out, transform 150ms ease-out;
}
.button:hover {
  background: var(--color-marca-hover);
  transform: scale(1.02);
}

/* Propiedades individuales */
.card {
  transition-property: transform, box-shadow, opacity;
  transition-duration: 200ms, 300ms, 200ms;
  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
}

/* Funciones de temporización nombradas */
--ease-in:        cubic-bezier(0.4, 0, 1, 1);     /* Acelerando */
--ease-out:       cubic-bezier(0, 0, 0.2, 1);     /* Desacelerando */
--ease-in-out:    cubic-bezier(0.4, 0, 0.2, 1);   /* Estándar */
--ease-spring:    cubic-bezier(0.34, 1.56, 0.64, 1); /* Sobreimpulso */

Patrones de Transición Comunes

/* Fundido de entrada/salida */
.fade-enter { opacity: 0; }
.fade-enter-active { opacity: 1; transition: opacity 300ms ease-out; }
.fade-exit { opacity: 1; }
.fade-exit-active { opacity: 0; transition: opacity 200ms ease-in; }

/* Deslizar hacia arriba desde abajo */
.slide-up {
  transform: translateY(20px);
  opacity: 0;
  transition: transform 300ms ease-out, opacity 200ms ease-out;
}
.slide-up.active {
  transform: translateY(0);
  opacity: 1;
}

/* Brillo de carga de esqueleto */
@keyframes shimmer {
  0% { background-position: -200% 0; }
  100% { background-position: 200% 0; }
}
.skeleton {
  background: linear-gradient(90deg, #e0e0e0 25%, #f0f0f0 50%, #e0e0e0 75%);
  background-size: 200% 100%;
  animation: shimmer 1.5s ease-in-out infinite;
}

CSS @keyframes

/* Spinner */
@keyframes spin {
  to { transform: rotate(360deg); }
}
.spinner {
  animation: spin 1s linear infinite;
  border: 3px solid var(--color-borde);
  border-top-color: var(--color-marca);
  border-radius: 50%;
  width: 24px; height: 24px;
}

/* Pulso (indicador de atención) */
@keyframes pulse {
  0%, 100% { opacity: 1; }
  50% { opacity: 0.5; }
}
.notification-dot {
  animation: pulse 2s ease-in-out infinite;
  background: red;
  border-radius: 50%;
  width: 10px; height: 10px;
  display: inline-block;
}

/* Animaciones escalonadas */
@keyframes fadeInUp {
  from {
    opacity: 0;
    transform: translateY(20px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}
.list-item {
  animation: fadeInUp 300ms ease-out both;
}
.list-item:nth-child(1) { animation-delay: 0ms; }
.list-item:nth-child(2) { animation-delay: calc(1 * 50ms); }
.list-item:nth-child(3) { animation-delay: calc(2 * 50ms); }

/* O con atributo de estilo: style="--i: 3" */
.list-item {
  animation-delay: calc(var(--i) * 50ms);
}

Animaciones CSS Impulsadas por Desplazamiento

/* Animar según la posición de desplazamiento */
@keyframes reveal {
  from {
    opacity: 0;
    transform: translateY(40px) scale(0.95);
  }
  to {
    opacity: 1;
    transform: translateY(0) scale(1);
  }
}

/* Activar cuando el elemento entra en el viewport */
.reveal-on-scroll {
  animation: reveal linear both;
  animation-timeline: view();
  animation-range: entry 0% entry 50%;
}

/* Efecto parallax (ejemplo simplificado) */
@keyframes parallax {
  from { transform: translateY(50px); }
  to { transform: translateY(-50px); }
}

.parallax-element {
  animation: parallax linear;
  animation-timeline: scroll();
}

Framer Motion (React)

Patrones Básicos

import { motion, AnimatePresence } from 'framer-motion';

// Animación de entrada
function Card() {
  return (
    <motion.div
      initial={{ opacity: 0, y: 20 }}
      animate={{ opacity: 1, y: 0 }}
      transition={{ duration: 0.3, ease: 'easeOut' }}
    >
      <h2>Card Content</h2>
    </motion.div>
  );
}

// Animación de salida (requiere AnimatePresence)
function Modal({ isOpen, onClose }: ModalProps) {
  return (
    <AnimatePresence>
      {isOpen && (
        <motion.div
          initial={{ opacity: 0, scale: 0.9 }}
          animate={{ opacity: 1, scale: 1 }}
          exit={{ opacity: 0, scale: 0.9 }}
          transition={{ duration: 0.2 }}
        >
          <h2>Título del Modal</h2>
          <p>Contenido del modal aquí.</p>
          <button onClick={onClose}>Cerrar</button>
        </motion.div>
      )}
    </AnimatePresence>
  );
}

// Animaciones de lista escalonada
const listVariants = {
  hidden: { opacity: 0 },
  visible: {
    opacity: 1,
    transition: {
      staggerChildren: 0.1,
    },
  },
};

const itemVariants = {
  hidden: { opacity: 0, y: 20 },
  visible: { opacity: 1, y: 0 },
};

function List({ items }: { items: Item[] }) {
  return (
    <motion.ul variants={listVariants} initial="hidden" animate="visible">
      {items.map((item) => (
        <motion.li key={item.id} variants={itemVariants}>
          {item.name}
        </motion.li>
      ))}
    </motion.ul>
  );
}

Física de Resortes

// Animación de resorte (movimiento natural basado en física)
<motion.div
  animate={{ x: 100 }}
  transition={{
    type: 'spring',
    stiffness: 300,   // Más alto = más rápido
    damping: 20,      // Más alto = menos rebote
    mass: 1,          // Más alto = más inercia
  }}
/>

// Ajustes predefinidos
const springPresets = {
  snappy:  { type: 'spring', stiffness: 400, damping: 25 },
  bouncy:  { type: 'spring', stiffness: 300, damping: 10 },
  gentle:  { type: 'spring', stiffness: 120, damping: 14 },
  molasses: { type: 'spring', stiffness: 60, damping: 20 },
};

// Cuándo usar resorte vs. easing:
// Resorte: elementos interactivos, arrastrar, cambios de diseño (se siente natural)
// Easing: transiciones simples, entrada/salida (se siente predecible)

Animaciones de Diseño

// Animación de diseño automática
function ExpandableCard({ expanded }: { expanded: boolean }) {
  return (
    <motion.div layout className={expanded ? 'card-expanded' : 'card-collapsed'}>
      <motion.h2 layout="position">Título</motion.h2>
      {expanded && (
        <motion.p
          initial={{ opacity: 0 }}
          animate={{ opacity: 1 }}
          exit={{ opacity: 0 }}
        >
          Contenido expandido aquí.
        </motion.p>
      )}
    </motion.div>
  );
}

// Reordenamiento de lista con layoutId
import { LayoutGroup, motion } from 'framer-motion';

function ReorderGrid({ items }: { items: Item[] }) {
  return (
    <LayoutGroup>
      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '1rem' }}>
        {items.map((item) => (
          <motion.div key={item.id} layout>
            {item.title}
          </motion.div>
        ))}
      </div>
    </LayoutGroup>
  );
}

Animaciones de Gestos

// Arrastrar
<motion.div
  drag
  dragConstraints={{ top: -100, bottom: 100, left: -100, right: 100 }}
  dragElastic={0.2}
  whileDrag={{ scale: 1.1, cursor: 'grabbing' }}
/>

// Hover y tap
<motion.button
  whileHover={{ scale: 1.05 }}
  whileTap={{ scale: 0.95 }}
  transition={springPresets.snappy}
>
  Haz clic
</motion.button>

// Activado por desplazamiento (con useInView)
import { useInView } from 'framer-motion';

function FadeInOnScroll({ children }: { children: React.ReactNode }) {
  const ref = useRef(null);
  const isInView = useInView(ref, { once: true, margin: '-50px' });

  return (
    <motion.div
      ref={ref}
      initial={{ opacity: 0, y: 20 }}
      animate={isInView ? { opacity: 1, y: 0 } : {}}
      transition={{ duration: 0.6, ease: 'easeOut' }}
    >
      {children}
    </motion.div>
  );
}

GSAP (Secuencias Temporales Complejas)

import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';

gsap.registerPlugin(ScrollTrigger);

// Secuencia de línea de tiempo
const tl = gsap.timeline({ defaults: { ease: 'power2.out', duration: 0.5 } });

tl.from('.hero-title', { y: 60, opacity: 0 })
  .from('.hero-subtitle', { y: 40, opacity: 0 }, '-=0.3')   // Superposición de 0.3s
  .from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.2')
  .from('.hero-image', { x: 100, opacity: 0 }, '-=0.4');

// Animación activada por desplazamiento
gsap.from('.feature-card', {
  scrollTrigger: {
    trigger: '.features-section',
    start: 'top 80%',
    end: 'bottom 20%',
    toggleActions: 'play none none reverse',
  },
  opacity: 0,
  y: 50,
  stagger: 0.15,
  duration: 0.6,
  ease: 'power2.out',
});

// Animaciones encadenadas con retraso
gsap.to('.box', {
  x: 200,
  duration: 1,
  ease: 'elastic.out(1, 0.3)',
  delay: 0.5,
});

// Limpieza de GSAP en React
useEffect(() => {
  const ctx = gsap.context(() => {
    // Todas las animaciones de GSAP aquí
    gsap.from('.item', { opacity: 0, y: 20, stagger: 0.1 });
  }, containerRef);

  return () => ctx.revert();  // Limpiar todas las animaciones
}, []);

Preferencias de Movimiento Reducido

Implementación

/* CSS: Respetar globalmente la preferencia del usuario */
@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
    scroll-behavior: auto !important;
  }
}
// React: hook useReducedMotion
function useReducedMotion(): boolean {
  const [reduced, setReduced] = useState(false);

  useEffect(() => {
    const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
    setReduced(mq.matches);
    const handler = (e: MediaQueryListEvent) => setReduced(e.matches);
    mq.addEventListener('change', handler);
    return () => mq.removeEventListener('change', handler);
  }, []);

  return reduced;
}

// Uso
function AnimatedCard() {
  const reduced = useReducedMotion();
  return (
    <motion.div
      initial={reduced ? {} : { opacity: 0, y: 20 }}
      animate={{ opacity: 1, y: 0 }}
      transition={reduced ? { duration: 0 } : { duration: 0.3 }}
    >
      Contenido
    </motion.div>
  );
}

// Framer Motion integrado (v6+)
import { useReducedMotion } from 'framer-motion';

Presupuesto de Rendimiento para Animaciones

OBJETIVO: Las animaciones deben mantener 60 fps (16.67 ms por fotograma)

REGLAS:
  1. Animar solo transform y opacity (propiedades solo del compositor)
  2. Evitar animar width, height, top, left, margin, padding
  3. Usar will-change con moderación (añade sobrecarga de memoria)
  4. Limitar las animaciones simultáneas a ~10-15 elementos
  5. Usar requestAnimationFrame para animaciones controladas por JS
  6. Desbancar los controladores de scroll (o usar animaciones CSS impulsadas por desplazamiento)
  7. Evitar animar elementos que provocan un reflujo en otros elementos

MEDICIÓN:
  - Chrome DevTools > Rendimiento > Gráfico de fotogramas
  - Objetivo: Ningún fotograma que supere los 16 ms
  - Verificar la presencia de layout thrashing (indicadores de reflujo forzado)

TÉCNICAS DE OPTIMIZACIÓN:
  - Usar transform: translateZ(0) o will-change para promover capas
  - Usar contain: layout paint para contenedores animados
  - Usar content-visibility: auto para contenido animado fuera de pantalla
  - Pausar animaciones cuando no son visibles (Intersection Observer)

Principios de Diseño de Animaciones

1. PROPÓSITO: Cada animación debe cumplir una función
   - Guiar la atención
   - Mostrar relaciones (padre-hijo, antes-después)
   - Proporcionar retroalimentación (clic, hover, éxito, error)
   - Mantener la orientación espacial (de dónde vino el contenido)
   - Reducir el tiempo de espera percibido

2. PAUTAS DE DURACIÓN:
   Micro-interacciones (hover, interruptor):  100-200 ms
   Animaciones de entrada:                    200-400 ms
   Animaciones de salida:                     150-300 ms (más rápidas que la entrada)
   Transiciones de página:                    300-500 ms
   Secuencias complejas:                      500-1000 ms en total

3. EASING:
   Entrada: ease-out (desacelerando -- aparece rápido, se asienta)
   Salida: ease-in (acelerando -- comienza lento, sale rápido)
   Movimiento: ease-in-out (movimiento natural)
   Continuo: linear (spinners, progreso)

4. ESCALONADO:
   30-80 ms entre elementos de la lista (más rápido para más elementos)
   Duración máxima total del escalonado: ~500 ms (incluso para 20+ elementos)

Lista de Verificación de Arquitectura de Animaciones

  • Herramienta de animación seleccionada según las necesidades de complejidad
  • Transiciones CSS utilizadas para efectos simples de hover/focus
  • CSS @keyframes utilizado para animaciones en bucle y de carga
  • Framer Motion o equivalente utilizado para animaciones de entrada/salida/diseño
  • GSAP reservado para secuencias temporales complejas
  • Todas las animaciones mantienen 60 fps (verificado en DevTools)
  • Solo se animan transform y opacity (sin propiedades de diseño)
  • prefers-reduced-motion respetado globalmente
  • Las duraciones de las animaciones siguen las pautas de UX (100-500 ms)
  • El tiempo de escalonado está limitado a una duración total razonable
  • Cada animación tiene un propósito claro (no decorativo)
  • Física de resortes utilizada para animaciones interactivas/de gestos
  • Las animaciones impulsadas por desplazamiento usan la API de CSS cuando es compatible
  • Las animaciones de GSAP se limpian al desmontar el componente
  • will-change usado solo durante la animación activa

Cuándo Usar

Usar este skill cuando:

  • Se diseñan o implementan soluciones de animación web
  • Se revisan o mejoran enfoques existentes de animación
  • Se toman decisiones arquitectónicas o de implementación sobre animación web
  • Se aprenden patrones y mejores prácticas de animación
  • Se solucionan problemas relacionados con la animación web

NO usar este skill cuando:

  • La pregunta trata sobre un dominio tecnológico fundamentalmente diferente
  • Un skill hermano más específico cubre exactamente el tema necesario
  • El usuario necesita un tutorial práctico completo en lugar de orientación experta

Formato de Salida

# Análisis de Animación Web

## Evaluación del Contexto
[Resumen de la situación y restricciones]

## Enfoque Recomendado
[Recomendación principal con fundamento]

## Pasos de Implementación
1. [Paso con detalles específicos]
2. [Paso con detalles específicos]
3. [Paso con detalles específicos]

## Compensaciones y Consideraciones
- [Compensación clave 1]
- [Compensación clave 2]

## Próximos Pasos
- [Acción inmediata]
- [Acción de seguimiento]

Ejemplo

Entrada: "Ayúdame a implementar animaciones web para una aplicación de producción de mediana escala"

Salida: Un análisis estructurado que cubre la evaluación del estado actual, el enfoque de animación web recomendado con patrones específicos, una hoja de ruta de implementación con hitos y estrategias de mitigación de riesgos adaptadas a la escala y las restricciones de la aplicación.

Casos Extremos

  • Integración con sistemas heredados: Cuando la animación web debe coexistir con enfoques heredados, proporcionar una ruta de migración gradual en lugar de una reescritura completa
  • Desajuste de escala: Cuando la complejidad de la solución supera la escala del proyecto, recomendar un enfoque más simple y señalar cuándo reconsiderarlo
  • Falta de habilidades del equipo: Cuando el equipo carece de experiencia con el enfoque recomendado, incluir recursos de aprendizaje y alternativas más simples
  • Requisitos conflictivos: Cuando las restricciones entran en conflicto (por ejemplo, rendimiento vs. mantenibilidad), exponer explícitamente la compensación y recomendar según las prioridades declaradas

Individual skills in this repo

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

FerroxLabs/murage

Writes board-level narrative updates that complement financial reports with strategic context, competitive positioning, key risks, and forward-looking guidance for board of directors audiences. Use when the user needs to write a board update, board meeting narrative, or director-level briefing. Do NOT use for stakeholder updates to management (use `stakeholder-update`), investor emails (use `investor-update-email`), or full business reports (use `business-report`).

FerroxLabs/murage

>- End-to-end workflow for building a professional photography portfolio from niche selection through shooting, editing, website creation, and client acquisition. Covers gear decisions, shooting technique, post-processing workflow, portfolio curation, online presence, and the transition from hobbyist to working photographer. Use when the user wants to build photography portfolio or needs a structured multi-step process for this goal. Do NOT use when the request is a single-step task or requires professional advice beyond educational guidance.

FerroxLabs/murage

>- End-to-end workflow for creating a high-converting SaaS landing page from copywriting through design, development, SEO optimization, and analytics setup. Covers persuasion frameworks, responsive design, performance optimization, and conversion tracking to turn visitors into customers. Use when the user wants to build saas landing page or needs a structured multi-step process for this goal. Do NOT use when the request is a single-step task or requires professional advice beyond educational guidance.

FerroxLabs/murage

Calculates startup burn rate (gross and net), projects cash runway in months, and builds scenario analysis for different spending and revenue trajectories. Use when the user asks about burn rate, cash runway, how long their money will last, or startup cash management. Do NOT use for personal savings calculations (use budget-planning), full financial modeling (use financial-model-structure), or fundraising narrative (use fundraising-narrative).

FerroxLabs/murage

The user is asking \"how long do we have,\" \"can we afford this hire,\" or \"are we running out.\" Load whenever cash, burn, or time-to-zero shows up — or when a spending decision is on the table and the user doesn't know how many months it costs.

FerroxLabs/murage

Professional corporate video production guidance covering training videos, promotional content, testimonials, and product demos. Includes client brief templates, script approval workflows, achieving professional quality on budget, brand compliance, stakeholder management, and delivery specifications. Use when the user asks about corporate video or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Helps artists, designers, and creative professionals curate, organize, and present their work through compelling portfolios across digital platforms, personal websites, and print formats for career advancement. Use when the user asks about creative portfolio builder, related techniques, best practices, or needs guidance in this domain. Do NOT use when the request is outside the scope of creative portfolio builder or requires a different specialized skill.

FerroxLabs/murage

Cross-discipline creative portfolio assessment evaluating artistic cohesion, technical skill, presentation quality, and market positioning. Produces a scored evaluation with recommendations for strengthening creative identity and professional opportunity. Use when the user asks about creative portfolio evaluator, related techniques, best practices, or needs guidance in this domain. Do NOT use when the request is outside the scope of creative portfolio evaluator or requires a different specialized skill.

FerroxLabs/murage

Professional design portfolio evaluation assessing design process, craft quality, range of work, presentation, and industry alignment. Produces a scored review with recommendations for strengthening design practice and career positioning. Use when the user asks about design portfolio reviewer, related techniques, best practices, or needs guidance in this domain. Do NOT use when the request is outside the scope of design portfolio reviewer or requires a different specialized skill.

FerroxLabs/murage

Teaches specific named emotional regulation techniques (the STOP technique, urge surfing, cognitive reframing, emotional labeling, opposite action, and physiological soothing) with step-by-step sequences. Gathers the user's emotional challenges and triggers, then produces a personalized regulation toolkit with technique instructions and a situation-response plan. Use when the user asks about managing emotions, controlling anger, handling frustration, emotional regulation strategies, or building emotional resilience. Do NOT use for clinical emotional dysregulation treatment, personality disorder management, or replacing professional mental health support.

FerroxLabs/murage

Structures a fundraising narrative for startup investors covering traction, market size, business model, use of funds, and milestone targets using standard VC pitch structure. Use when the user asks about fundraising pitch, investor narrative, raising capital, pitch deck story, or investment memo. Do NOT use for sales pitch decks (use sales-pitch-deck), personal loan applications, grant proposals (use grant-proposal-writing), or financial model creation (use financial-model-structure).

FerroxLabs/murage

Interactive storytelling for games covering branching narratives, dialogue trees, environmental storytelling, lore design, character writing for games, quest design, player agency, world-building for interactive media, and narrative integration with game mechanics. Use when the user asks about game narrative writer or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Writes Instagram captions with a hook line, story body, hashtag strategy, and platform-optimized call-to-action. Use when the user wants to write an Instagram caption, create Instagram content, or draft text to accompany an Instagram post or reel. Do NOT use for LinkedIn posts (use `linkedin-post`), Twitter threads (use `twitter-thread`), or blog posts (use `blog-post-writing`).

FerroxLabs/murage

Produces conversion-optimized landing page copy with hero section, problem statement, solution, social proof, and CTA sections using conversion copywriting methodology. Use when the user asks to write landing page copy, create a product page, write a sales page, draft conversion copy, or write landing page text for a website. Also useful when asked to write website copy or create a page that converts visitors. Do NOT use for ad copy (use paid-ad-copy), product descriptions for e-commerce listings (use product-description), or full website content strategy (use seo-content-strategy).

FerroxLabs/murage

Guides the user through launching a professional art or creative portfolio from curation through outreach, chaining 5 atomic skills across career-development, design-creative, and writing categories. Covers physical vs. digital portfolio, platform selection, fine art vs. commercial positioning, and curated vs. comprehensive approaches. Use when the user wants to create and launch a portfolio to attract clients, galleries, or employers. Do NOT use for building a job search portfolio in non-creative fields (use land-new-job workflow), personal brand content strategy (use build-personal-brand workflow), or creating the artwork itself.

FerroxLabs/murage

>- Complete YouTube channel launch workflow from niche selection and channel strategy through video production, editing, monetization setup, community building, and personal brand development for sustainable channel growth. Use when the user wants to launch youtube channel or needs a structured multi-step process for this goal. Do NOT use when the request is a single-step task or requires professional advice beyond educational guidance.

FerroxLabs/murage

Run a section-by-section conversion teardown of one landing page — hero, value proposition, social proof, features, objection handling, CTA and footer — plus form, mobile and page-speed audits, ending in prioritised fixes split into quick wins, strategic and long-term, with A/B test hypotheses. Use when one page has traffic and is not converting. Do NOT use for a whole-site marketing audit (use market-audit), for the copy voice and awareness-stage decisions behind it (use copy-awareness-stages) or for the visual system it should sit inside (use mira-visual-system).

FerroxLabs/murage

Comprehensive motion graphics guidance covering title design, lower thirds, animated explainers, kinetic typography, logo animation, After Effects and Apple Motion workflows, design principles for motion, storyboarding for motion, and building a motion design practice. Use when the user asks about motion graphics or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Game narrative design covering branching dialogue systems, world lore construction, environmental storytelling techniques, character arc design for interactive media, player agency and consequence systems, quest narrative structure, narrative documentation, and integration with game mechanics. Use when the user asks about narrative designer or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Comprehensive animation guidance covering the 12 principles of animation, 2D and 3D production pipelines, tools (Blender, After Effects, Procreate, Toon Boom), frame rates, rigging, motion graphics vs character animation, and building an animation practice from concept to final render. Use when the user asks about animation creator or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

Skills relacionados