Skip to main content
skill CX Codex

responsive-adaptive — Claude Code skill: what it does, how to install

Adjusts UI animation timing to viewport dimensions, travel distance, and reduced motion settings instead of using static durations.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add dylantarre/animation-principles --skill responsive-adaptive -a claude-code
Open on GitHub

What responsive-adaptive does

The skill provides guidelines for building context-aware UI transitions. It alters transition speeds depending on context: touch interactions get 25% faster pacing than desktop clicks, while mobile viewports reduce duration by 20%. When elements travel longer distances, duration scales via a square-root formula up to 600ms so large movements do not feel jarring.

It translates classic Disney motion rules to modern frontends. Anticipation stages are trimmed for touch displays because finger taps demand prompt feedback. Secondary actions and heavy 3D transforms get dropped on mobile screens to protect frame rates. For prefers-reduced-motion, it provides options for instantaneous 0.01ms cutoffs or subtle 100ms opacity fades.

Without centralizing duration tokens inside root CSS custom properties, maintaining these adaptive rules across media queries quickly turns into tedious manual overrides.

What it helps with

  • scale transition speed based on pixel travel distance
  • shorten animation latency for touch and mobile screens
  • implement reduced-motion fallbacks using pure opacity fades
  • strip heavy secondary motion on mobile devices to preserve frame rates

Example prompts for the agent

  • Create root CSS custom properties for animation speeds with mobile media queries
  • Write a JavaScript helper that calculates transition length from travel distance
  • Apply prefers-reduced-motion rules to disable transforms while keeping opacity fades

How to install responsive-adaptive

1Skills CLI (Vercel)

npx skills add dylantarre/animation-principles --skill responsive-adaptive -a claude-code

2Manually: put the files in place

~/.claude/skills/responsive-adaptive/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/responsive-adaptive/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about responsive-adaptive

How do I install responsive-adaptive in Claude Code?

Run npx skills add dylantarre/animation-principles --skill responsive-adaptive -a claude-code. The file will be placed into ~/.claude/skills/responsive-adaptive/SKILL.md.

What does the responsive-adaptive skill do?

It guides coding agents on adjusting UI transition timing according to viewport width, input type, travel distance, and accessibility settings.

How does it scale timing for travel distance?

It uses a baseline of 300ms for 100px travel and multiplies it by the square root of the distance ratio, capped at 600ms.

Source text

SKILL.md · MIT
---
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.

© dylantarre · MIT · dylantarre/animation-principles

Similar skills

Everything for Frontend and UI →

From the same set142

Animation Principles - Refresher A concise 12-principles animation checklist without basic theory. Helps experienced animators quickly audit shots, diagnose floaty or stiff movement, and prioritize principles. CX Codex +1 489installs Animation Principles - Advanced A skill for animators who already know the fundamentals and want the nuances: invisible squash/stretch, missing anticipation, deliberately broken arcs. CX Codex +1 489installs emotional-disconnect Diagnoses why an animation feels wrong and matches motion to the emotion the moment should carry. Useful when users call your UI cold or annoying. CX Codex +1 488installs state-changes A skill for animating elements that transform in place: toggles, accordions, checkboxes, button states. Useful when an interface needs smooth transitions without enter or exit. CX Codex +1 489installs Animation Principles - Intermediate Guides animators through combining individual motion principles in complex scenes. Useful when fundamentals are clear but multi-element actions feel disjointed. CX Codex +1 487installs Animation Principles - Deep Dive A reference skill covering Disney's 12 animation principles with technical detail: deformation ratios, frame counts, arcs, follow through. Useful when the agent needs animation context. CX Codex +1 487installs Animation Principles - Novice A skill that walks through the 12 animation principles with a hands-on exercise for each. Useful once you know the theory and want to actually use it. CX Codex +1 488installs professionalism-credibility Sets motion design guidelines for enterprise dashboards and B2B software. Helps implement clean, predictable UI transitions without playfulness. CX Codex +1 487installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor