Skip to main content
skill CX Codex

slow-800-1200ms — Claude Code skill for 800–1200ms motion

A coding-agent skill for building deliberately slow animation in the 800–1200ms range: dramatic reveals, loading sequences, moments where the user should stop and watch.

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

What slow-800-1200ms does

This skill covers animation that runs 800–1200ms, which the source calls cinematic territory. It walks through the Disney principles at that speed: pronounced squash and stretch at 25–35%, a theatrical 200–300ms wind-up, 4–6 key poses per second of motion, and follow through where elements settle 200–300ms apart. The point is motion for moments that matter.

You get CSS easing curves ready to paste. cubic-bezier(0.16, 1, 0.3, 1) at 1000ms reads as heavy and weighted; cubic-bezier(0.68, -0.6, 0.32, 1.6) lands elastic and memorable. There is a @keyframes slowReveal pattern plus a staggered sequence using calc(var(--index) * 150ms) so items arrive one after another. Frame counts are given as 48–72 at 60fps.

The skill also names where this backfires: view navigation, repeated interactions, high-frequency actions, data-heavy interfaces and productivity tools. Slow motion charges attention as payment, so navigation feels sluggish. Worth checking whether your case is really an app launch, a major feature reveal or an achievement unlock before you reach for it.

What it helps with

  • build a dramatic app launch reveal on first run
  • stage an achievement unlock users actually remember
  • smooth the handoff from loading state to content
  • stagger a sequence of elements with per-index delay
  • pick easing curves for heavy versus elastic motion

Example prompts for the agent

  • Make the app launch reveal slow, in the 800–1200ms range, with a strong ease-out
  • Add a staggered card entrance using @keyframes slowReveal with calc(var(--index) * 150ms) delay
  • Pick an easing curve for an elastic modal entrance at 1000ms

How to install slow-800-1200ms

1Skills CLI (Vercel)

npx skills add dylantarre/animation-principles --skill slow-800-1200ms -a claude-code

2Manually: put the files in place

~/.claude/skills/slow-800-1200ms/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/slow-800-1200ms/

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

Questions about slow-800-1200ms

How do I install slow-800-1200ms in Claude?

Run npx skills add dylantarre/animation-principles --skill slow-800-1200ms -a claude-code. The skill lands at ~/.claude/skills/slow-800-1200ms/SKILL.md.

What does slow-800-1200ms do?

It guides the agent through building deliberate 800–1200ms animation, covering the Disney principles at that speed, CSS easing curves and a staggered reveal pattern.

When should I not use slow animation?

The skill lists view navigation, repeated interactions, high-frequency actions, data-heavy interfaces and productivity tools, where users get impatient.

Source text

SKILL.md · MIT
---
name: slow-800-1200ms
description: Use when building deliberate motion between 800-1200ms - dramatic reveals, loading sequences, storytelling moments where users should pause and absorb
---

# Slow Animations (800-1200ms)

At 800-1200ms, animation approaches **cinematic territory**. This is deliberate, intentional motion for moments that matter. Users are expected to stop and watch.

## Disney Principles at Slow Speed

### Cinematic Application

**Squash & Stretch**: Pronounced and characterful - 25-35% deformation tells stories. Objects have weight and personality.

**Anticipation**: Full theatrical wind-up - 200-300ms preparation. The audience knows something is coming.

**Staging**: Scene composition - think in terms of camera and stage. Clear visual hierarchy with entrance order.

**Straight Ahead/Pose to Pose**: Pose to pose essential - 4-6 key poses for 1 second of motion.

**Follow Through**: Extended overlap - different elements settle at clearly different times, 200-300ms of settling.

**Slow In/Slow Out**: Dramatic curves - strong ease-in creates weight, strong ease-out creates impact.

**Arcs**: Sweeping curves - motion paths are clearly curved, visible trajectories.

**Secondary Action**: Complex layering - multiple levels of supporting action enhance primary motion.

**Timing**: 48-72 frames at 60fps. Near-film quality frame counts.

**Exaggeration**: Theatrical - push proportions and motion for emotional impact.

**Solid Drawing**: Full dimensional transforms - parallax, depth, 3D rotation.

**Appeal**: Emotional connection - slow motion creates intimacy with the interface.

## Easing Recommendations

```css
/* Dramatic, weighted motion */
transition: all 1000ms cubic-bezier(0.16, 1, 0.3, 1);

/* Graceful entrance */
transition: all 900ms cubic-bezier(0.22, 1, 0.36, 1);

/* Heavy, impactful landing */
transition: transform 1100ms cubic-bezier(0.33, 1, 0.68, 1);

/* Elastic, memorable */
transition: all 1000ms cubic-bezier(0.68, -0.6, 0.32, 1.6);
```

## Best Use Cases

- App launch sequences
- Major feature reveals
- Storytelling moments
- Error recovery animations
- Achievement unlocks
- Tutorial sequences
- First-run experiences
- Section transitions in presentations
- Loading state to content reveals

## Implementation Pattern

```css
@keyframes slowReveal {
  0% {
    opacity: 0;
    transform: translateY(100px) scale(0.8);
  }
  60% {
    opacity: 1;
  }
  100% {
    transform: translateY(0) scale(1);
  }
}

.slow-reveal {
  animation: slowReveal 1000ms cubic-bezier(0.16, 1, 0.3, 1) forwards;
}

/* Staggered sequence */
.sequence-item {
  animation: slowReveal 900ms cubic-bezier(0.22, 1, 0.36, 1) forwards;
}
.sequence-item:nth-child(n) {
  animation-delay: calc(var(--index) * 150ms);
}
```

## When NOT to Use

- Navigation between views (too slow)
- Repeated interactions (users get impatient)
- High-frequency actions
- Data-heavy interfaces
- Productivity tools

## Key Insight

Slow animations demand **attention as payment**. Only use when the moment is worth the user's time. These animations create memories, not just feedback.

© dylantarre · MIT · dylantarre/animation-principles

Similar skills

Everything for Frontend and UI →

From the same set86

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