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.
npx skills add dylantarre/animation-principles --skill responsive-adaptive -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/responsive-adaptive/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/responsive-adaptive/
1Skills CLI (Vercel)
npx skills add dylantarre/animation-principles --skill responsive-adaptive -a codex2Manually: put the files in place
.agents/skills/responsive-adaptive/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add dylantarre/animation-principles --skill responsive-adaptive -a cursor2Manually: put the files in place
.cursor/skills/responsive-adaptive/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install dylantarre/animation-principles responsive-adaptive2Manually: put the files in place
.github/skills/responsive-adaptive/SKILL.md1Skills CLI (Vercel)
npx skills add dylantarre/animation-principles --skill responsive-adaptive -a gemini-cli2Platform CLI
gemini skills install https://github.com/dylantarre/animation-principles --path skills/10-by-time-scale/responsive-adaptiveManually: put the files in place
.devin/skills/responsive-adaptive/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add dylantarre/animation-principles --skill responsive-adaptive -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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