home / skills / dylantarre / animation-principles / responsive-adaptive

responsive-adaptive skill

/skills/10-by-time-scale/responsive-adaptive

This skill helps tailor animation timing to device, distance, and user context, delivering fluid experiences across platforms.

npx playbooks add skill dylantarre/animation-principles --skill responsive-adaptive

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

Files (1)
SKILL.md
3.8 KB
---
name: responsive-adaptive
description: Use when building context-dependent animations - duration that changes based on device, distance, user preference, or interaction context
---

# Responsive & Adaptive Timing

Responsive timing adapts duration to **context**: device capability, travel distance, user preferences, and interaction type. One duration doesn't fit all situations.

## Disney Principles for Adaptive Motion

### Context-Aware Application

**Squash & Stretch**: Scale with device - more subtle on mobile (less screen real estate for deformation).

**Anticipation**: Shorter on touch devices - touch users expect faster response than mouse users.

**Staging**: Adapt to viewport - smaller screens need more focused staging, less simultaneous motion.

**Straight Ahead/Pose to Pose**: Same approach, scaled duration - poses stay, timing adjusts.

**Follow Through**: Proportional to distance - longer travel = more follow-through time.

**Slow In/Slow Out**: Adjust curve intensity - faster animations need sharper easing.

**Arcs**: Same paths, different speeds - arc shape remains, traversal time changes.

**Secondary Action**: Reduce on mobile - fewer simultaneous animations for performance.

**Timing**: THE adaptive variable - timing changes, principles stay.

**Exaggeration**: Less on smaller screens - proportional to viewport/element size.

**Solid Drawing**: Performance-aware - reduce 3D transforms on weaker devices.

**Appeal**: Context-appropriate - what feels right on desktop may feel slow on mobile.

## Adaptive Strategies

### Distance-Based Duration

```css
/* Base duration for reference distance */
--base-duration: 300ms;
--base-distance: 100px;

/* Duration scales with distance */
/* 50px travel = 200ms, 200px travel = 450ms */
```

```javascript
function getDuration(distance) {
  const baseDuration = 300;
  const baseDistance = 100;
  return Math.min(600, baseDuration * Math.sqrt(distance / baseDistance));
}
```

### Device-Based Duration

```css
/* Desktop - full duration */
.transition { transition-duration: 400ms; }

/* Tablet - slightly faster */
@media (max-width: 1024px) {
  .transition { transition-duration: 350ms; }
}

/* Mobile - faster for perceived responsiveness */
@media (max-width: 768px) {
  .transition { transition-duration: 250ms; }
}
```

### Preference-Based Duration

```css
/* Respect reduced motion preference */
@media (prefers-reduced-motion: reduce) {
  .transition {
    transition-duration: 0.01ms !important;
    animation-duration: 0.01ms !important;
  }
}

/* Reduce motion, don't eliminate */
@media (prefers-reduced-motion: reduce) {
  .transition {
    transition-duration: 100ms;
    transform: none; /* Only opacity fades */
  }
}
```

## Context Rules

| Context | Duration Adjustment |
|---------|---------------------|
| Touch device | -25% from desktop |
| Small viewport | -20% from desktop |
| Large travel distance | +50% base |
| Small travel distance | -30% base |
| User prefers reduced | Instant or minimal |
| Low power mode | -50% or disabled |
| High-frequency action | Use minimum duration |
| First-time view | Full duration |
| Repeat interaction | Reduced duration |

## Implementation Pattern

```css
:root {
  --duration-instant: 50ms;
  --duration-fast: 150ms;
  --duration-normal: 300ms;
  --duration-slow: 500ms;
}

@media (max-width: 768px) {
  :root {
    --duration-fast: 100ms;
    --duration-normal: 200ms;
    --duration-slow: 350ms;
  }
}

@media (prefers-reduced-motion: reduce) {
  :root {
    --duration-instant: 0ms;
    --duration-fast: 0ms;
    --duration-normal: 100ms;
    --duration-slow: 150ms;
  }
}
```

## Key Insight

Great animation adapts like typography adapts - what works at one size/context may not work at another. Build **systems**, not fixed values. Test across contexts. Duration is a variable, not a constant.

Overview

This skill helps designers and engineers create responsive, context-aware animation timing that adapts durations to device, distance, user preference, and interaction context. It applies Disney-inspired animation principles to modern UI motion systems so timing feels right across screens, input types, and performance conditions. The goal is systems-based timing, not fixed values.

How this skill works

The skill inspects runtime context (viewport size, input type, travel distance, reduced-motion and low-power preferences, and interaction frequency) and maps those signals to duration, easing, and secondary-animation intensity. It provides formulas, CSS variable patterns, media-query fallbacks, and small JS helpers to compute scaled durations (distance-scaling, device modifiers, and preference overrides). It also suggests when to shorten, lengthen, or disable motion per context.

When to use it

  • Designing UI motion systems that must work across desktop, tablet, and mobile.
  • Animating elements with variable travel distances (e.g., drag, fly-in, list reordering).
  • Respecting user motion preferences and device power/performance constraints.
  • Implementing first-run onboarding animations versus repeated interactions.
  • Tuning multi-layer or secondary animations for different screen sizes.

Best practices

  • Treat duration as a variable: build tokens (instant/fast/normal/slow) and scale them by context.
  • Prefer proportional rules (sqrt or linear distance scaling) rather than arbitrary constants.
  • Respect prefers-reduced-motion and low-power modes—reduce or remove transform-heavy motion.
  • Shorten anticipation and follow-through on touch devices to match perceived responsiveness.
  • Limit simultaneous secondary actions on small or low-power devices to preserve clarity and performance.

Example use cases

  • Scaling a fly-to-cart animation so short drags finish quickly and long drags feel weighty.
  • Adjusting onboarding micro-animations: full-duration for first view, reduced on repeats.
  • Applying faster easing and reduced secondary motion on mobile to preserve perceived speed.
  • Using CSS variables plus media queries to maintain consistent motion tokens across breakpoints.
  • Automatically minimizing animations when prefers-reduced-motion or low-power mode is active.

FAQ

How do I pick a scaling function for distance?

Use a gentle curve like sqrt(distance/base) to avoid extremes; clamp to a min/max to keep durations sensible.

Should I remove all motion for reduced-motion users?

Prefer minimizing or simplifying motion (opacity fades, shorter durations) rather than eliminating all feedback unless strictly required.