Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Framer Motion Animation Sequencer

    1

    Generate production-ready, accessible Framer Motion sequences with staggered transitions and GPU-optimized performance.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Framer Motion Animation Sequencer

    Framer Motion Animation Sequencer

    Example session with this skill installed

    Create a staggered entrance animation for a grid of 6 cards using Framer Motion. Ensure it supports reduced motion and handles exit animations.

    • Read your context and instructions
    • Compiled the framer motion animation

    I have generated a React component for your staggered grid. It uses declarative variants for clean orchestration and includes a useReducedMotion check to ensure accessibility for all users.

    Staggered Grid Component

    import React from 'react';
    import { motion, AnimatePresence, useReducedMotion } from 'framer-motion';
    
    const containerVariants = {
      hidden: { opacity: 0 },
      visible: {
        opacity: 1,
        transition: {
          staggerChildren: 0.1,
          delayChildren: 0.2,
        },
      },
      exit: {
        opacity: 0,
        transition: { staggerChildren: 0.05, staggerDirection: -1 }
      }
    };
    
    const itemVariants = {
      hidden: { opacity: 0, y: 20 },
      visible: { 
        opacity: 1, 
        y: 0,
        transition: { duration: 0.5, ease: "easeOut" }
      },
      exit: { opacity: 0, scale: 0.95 }
    };
    
    export const AnimatedGrid = ({ items, isVisible }) => {
      const shouldReduceMotion = useReducedMotion();
    
      // Override variants if user prefers reduced motion
      const accessibleItemVariants = shouldReduceMotion 
        ? { hidden: { opacity: 0 }, visible: { opacity: 1 }, exit: { opacity: 0 } }
        : itemVariants;
    
      return (
        <AnimatePresence>
          {isVisible && (
            <motion.div
              className="grid grid-cols-3 gap-4"
              variants={containerVariants}
              initial="hidden"
              animate="visible"
              exit="exit"
            >
              {items.map((item) => (
                <motion.div
                  key={item.id}
                  className="p-4 bg-white shadow-md rounded-lg"
                  variants={accessibleItemVariants}
                >
                  {item.content}
                </motion.div>
              ))}
            </motion.div>
          )}
        </AnimatePresence>
      );
    };
    

    Next steps

    1. Install the dependency if you haven't: npm install framer-motion.
    2. Wrap your application or parent component in AnimatePresence if the grid itself is unmounting.
    3. Pass the isVisible prop to trigger the entrance and exit sequences.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Building complex UI animations in React often leads to janky performance, messy code, and poor accessibility. This skill generates production-ready Framer Motion sequences that follow performance best practices and accessibility standards.

    What it does

    • Declarative Variants: Structures motion components using clean variant objects with staggered child transitions.
    • Exit Gestures: Implements AnimatePresence to handle component mount and unmount transitions without layout shifts.
    • Accessibility Integration: Automatically wraps animations in useReducedMotion hooks to respect OS-level preferences.
    • Performance Tuning: Forces GPU acceleration by prioritizing transform and opacity properties over layout-triggering attributes.

    How it works

    1. Define the Scope: Provide the React component structure or the specific UI interaction you want to animate.
    2. Variant Generation: The agent generates the motion variants, including initial, animate, and exit states.
    3. Refinement: It applies orchestration properties like staggerChildren or delayChildren for sequenced effects.
    4. Accessibility Check: It injects logic to disable or simplify motions based on user system settings.

    Frameworks & tools

    This skill is built for React and TypeScript projects using the framer-motion library. It is compatible with Next.js and standard Vite-based React stacks.

    Why this beats prompting it yourself

    Generic prompts often produce animations that trigger browser repaints or ignore users with vestibular sensitivities. This skill enforces a deterministic workflow that prioritizes 60fps performance and WCAG-compliant motion handling by default.

    Use cases

    • Create staggered list entry animations for dashboard data.
    • Build smooth page transitions for Next.js applications.
    • Implement accessible modal and drawer entrance/exit sequences.
    • Develop interactive hover and gesture-based UI feedback.

    Known limitations

    This skill focuses on Framer Motion and does not support GSAP or vanilla CSS keyframes. It requires a React environment with the framer-motion package already installed.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Frontend & Web Apps.

    Requires React and framer-motion library. Focused on transform and opacity properties. No support for GSAP or direct CSS-only animations.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    Software
    Zero global installation
    orelevated privileges required.

    File System Read/Write (strictly scoped to current project workspace `./`).

    Permissions

    Read Files

    Target Use Cases: - Create a staggered list animation with Framer Motion in React. - Implement page transition animations with AnimatePresence. - Add reduced motion support to Framer Motion animations.

    Listed3 days ago

    What's inside

    Frequently Asked Questions

    This skill generates structured Framer Motion variant objects and components that prioritize GPU-accelerated properties (transform/opacity) and automatically implement 'useReducedMotion' hooks for WCAG compliance.

    Yes, it is fully compatible with React-based frameworks including Next.js (both Pages and App Router) and Vite, provided the 'framer-motion' library is installed in your project.

    The skill generates ready-to-use React code blocks including motion variants, orchestration logic (staggering/delays), and accessibility wrappers that you can copy directly into your components.

    While the skill optimizes for 60fps by avoiding layout-triggering properties, it requires a React environment; it does not support GSAP, vanilla CSS keyframes, or non-React frameworks.

    No complex setup is needed—simply provide your component structure or desired interaction to the agent, and it will output the necessary Framer Motion logic tailored to your specific UI.

    New in Frontend & Web Apps