home / skills / richtabor / agent-skills / motion-design

motion-design skill

/skills/motion-design

This skill provides motion design guidance for UI components, recommending easing, duration, and implementation to make interactions purposeful and delightful.

npx playbooks add skill richtabor/agent-skills --skill motion-design

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
5.0 KB
---
name: motion-design
description: Provides motion design guidance for UI components. Triggers on animation requests ("animate this", "add transition", "motion for"), refinement requests ("clean up this animation", "clean up the motion", "this feels too fast/slow", "make this feel more alive/natural"), and questions about easing, timing, or micro-interactions.
---

# Motion Design

## Overview

Design intentional, purposeful motion for product UI. This skill evaluates animation needs and recommends specific easing curves, durations, and implementation approaches based on interaction frequency and purpose.

Every animation needs a job. If it has no job, don't animate.

## Process

### Phase 1: Load References (Required)

Before any recommendations, read both reference files:

1. **Decision Tree** (`references/decision-tree.md`) - Which easing category to use based on the interaction type, plus scale/origin/hover guidance
2. **Easing Tokens** (`references/easing-tokens.md`) - Specific curves, duration values, and performance guidelines

### Phase 2: Evaluate the Animation

For each component or interaction, determine:

**2.1 Purpose**

What job does this animation do?

- **Responsiveness** - Button press, menu open, immediate feedback
- **Spatial continuity** - Things come from somewhere and go somewhere
- **Understanding** - Illustrating a concept, onboarding, marketing
- **Delight** - Rare interactions only (use sparingly)

If no clear purpose exists, recommend no animation.

**2.2 Frequency**

How often will users trigger this?

- **High-frequency / keyboard-driven** - Prefer no animation or near-instant
- **Medium-frequency / common interactions** - Keep it fast (120-240ms)
- **Low-frequency / illustrative** - More freedom for slower, richer motion

**2.3 Pattern Type**

What kind of motion is this?

- **Enter/exit** - Popover, modal, toast, dropdown appearing or leaving (exits are typically faster than enters—users want things gone quickly)
- **On-screen morph** - Layout shift, expanding content, repositioning
- **Time-based** - Progress indicator, marquee, hold-to-delete
- **Hover/subtle** - Color change, opacity fade, background shift
- **Keyboard navigation** - Arrow keys, tab focus, rapid selection

### Phase 3: Recommend

Based on the evaluation, provide specific recommendations using tokens from the reference files.

## Output Format

For each animation request, provide:

```
## Animation Recommendation

**Component**: [What's being animated]

### Evaluation
- **Purpose**: [responsiveness / spatial / understanding / delight / none]
- **Frequency**: [high / medium / low]
- **Pattern**: [enter-exit / morph / time-based / hover / keyboard]

### Recommendation
- **Easing**: [token name] — `[cubic-bezier value]`
- **Duration**: [token name] — `[ms value]`
- **Properties**: [transform, opacity, etc.]
- **Transform Origin**: [if applicable]
- **Spring vs Bezier**: [recommendation and why]
- **Bounce**: [yes/no and why]

### Implementation
[Code snippet or CSS/JS example]

### Notes
[Any specific guidance for this case]
```

## Example Interaction

**User**: "How should I animate this dropdown menu?"

**Response**:

```
## Animation Recommendation

**Component**: Dropdown menu

### Evaluation
- **Purpose**: Responsiveness — immediate feedback when user clicks trigger
- **Frequency**: Medium — common interaction but not rapid-fire
- **Pattern**: Enter/exit — appearing and disappearing from screen

### Recommendation
- **Easing**: --ease-out-quart — `cubic-bezier(.165, .84, .44, 1)`
- **Duration**: --dur-2 — `180ms`
- **Properties**: transform (scale, translateY), opacity
- **Transform Origin**: Top center (or top-left/top-right based on trigger position)
- **Spring vs Bezier**: Bezier is fine here; spring useful if menu can be interrupted mid-animation
- **Bounce**: No — tap-to-open shouldn't bounce

### Implementation
```css
.dropdown {
  transform-origin: top center;
  transition:
    transform 180ms cubic-bezier(.165, .84, .44, 1),
    opacity 180ms cubic-bezier(.165, .84, .44, 1);
}

.dropdown[data-state="closed"] {
  opacity: 0;
  transform: scale(0.96) translateY(-8px);
}

.dropdown[data-state="open"] {
  opacity: 1;
  transform: scale(1) translateY(0);
}
```

### Notes
- Use scale(0.96), not scale(0)
- Set transform-origin to match trigger position
- Keep under 240ms for snappy feel
```

## Tips for Best Results

1. **Be specific about the component** - "dropdown" vs "modal" vs "tooltip" matters
2. **Mention the trigger** - Click, hover, keyboard, scroll
3. **Share context** - "This is a productivity app" vs "marketing landing page"
4. **Ask about multiple states** - Open, close, hover, disabled
5. **Specify framework** - CSS, Framer Motion, GSAP, React Spring

## Resources

This skill includes:

### references/decision-tree.md
Flowchart for choosing the right easing category based on interaction type. Includes scale values, transform-origin guidance, hover/touch considerations, and accessibility.

### references/easing-tokens.md
Complete set of easing curves (ease-out, ease-in-out families), duration tokens, and performance guidelines.

Overview

This skill provides focused motion design guidance for UI components, recommending easing curves, durations, and implementation patterns tailored to purpose and frequency. It enforces the principle that every animation must have a job and refuses unnecessary motion. Outputs are practical, token-based recommendations you can drop into CSS or JS animation libraries.

How this skill works

I first identify the animation’s purpose (responsiveness, spatial continuity, understanding, or delight), its frequency (high, medium, low), and the pattern type (enter/exit, morph, time-based, hover, or keyboard). Using those inputs I map to proven easing tokens and duration ranges, then produce a concise recommendation with properties, transform origin, and implementation notes. I also call out when to prefer springs versus beziers and when to avoid bounce.

When to use it

  • When you need a concrete easing + duration for a specific component (dropdown, modal, toast).
  • When an animation feels too slow, too fast, or disconnected and needs refinement.
  • When deciding whether to animate an interaction at all (validate the animation’s job).
  • When implementing micro-interactions for high-frequency keyboard or accessibility-driven flows.
  • When choosing between spring and bezier implementations for interruptible motion.

Best practices

  • Start by naming the component and trigger (e.g., dropdown on click, tooltip on hover).
  • Always define the animation’s job; if none exists, recommend no motion.
  • Match duration to frequency: high-frequency near-instant, medium 120–240ms, low 300ms+ for illustrative motion.
  • Prefer transform and opacity for better performance; avoid animating layout properties when possible.
  • Set transform-origin to match the visual origin of motion (trigger position) and keep bounce minimal or absent for responsive controls.

Example use cases

  • Animate a dropdown opening from a button with an ease-out quart and ~180ms duration; transform-origin at the trigger.
  • Refine a button press to be instant or near-instant for keyboard-driven flows (20–80ms) to preserve responsiveness.
  • Create a slower, more illustrative modal entrance for onboarding with a longer ease-in-out and subtle opacity shift.
  • Tweak hover micro-interactions to subtle scale or translate with short durations and no bounce for a natural feel.

FAQ

What if my animation is interruptible by user actions?

Prefer springs for interruptible motion because they handle mid-animation interruptions more naturally; use bezier for clean, predictable timing when interruptions are unlikely.

How do I choose duration for keyboard-driven interactions?

Keep keyboard interactions very fast or near-instant (20–80ms) to avoid disrupting rapid navigation; use slightly longer only for necessary spatial cues.

When should I allow bounce?

Use bounce sparingly for low-frequency delight moments that benefit from playful feedback; avoid bounce for responsiveness or common controls.