home / skills / dylantarre / animation-principles / transition-sequences

This skill helps orchestrate multi-step animations using Disney principles to craft smooth, engaging page transitions and guided UI reveals.

npx playbooks add skill dylantarre/animation-principles --skill transition-sequences

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

Files (1)
SKILL.md
3.4 KB
---
name: transition-sequences
description: Use when orchestrating multi-step animations - page transitions, onboarding flows, wizard steps, complex reveals, or any choreographed animation sequence.
---

# Transition Sequence Animations

Apply Disney's 12 principles to choreographed multi-step motion.

## Principle Application

**Squash & Stretch**: Each element in sequence can compress/expand independently for organic feel.

**Anticipation**: Sequence starts with a setup phase. Brief pause or gather before motion begins.

**Staging**: Direct attention through the sequence. Most important element animates first or last.

**Straight Ahead vs Pose-to-Pose**: Plan keyframes for each step. Map the entire sequence before implementing.

**Follow Through & Overlapping**: Elements don't move in unison. Stagger starts by 50-100ms. Let motion cascade.

**Slow In/Slow Out**: Each step eases. The sequence overall should ease too - faster middle, slower ends.

**Arcs**: Transitions across space follow arcs. Page sliding left curves slightly, not linear slide.

**Secondary Action**: Primary transition + secondary details. Page slides while elements within fade/scale.

**Timing**:
- Step overlap: 30-50% of previous step's duration
- Total sequence: 300-800ms for UI, up to 1500ms for dramatic
- Gap between steps: 0-100ms (overlap preferred)

**Exaggeration**: Sequence itself is exaggeration. Individual steps stay subtle.

**Solid Drawing**: Maintain spatial consistency. If A goes left, B should come from left.

**Appeal**: Sequences tell a story. Beginning, middle, end - satisfying resolution.

## Timing Recommendations

| Sequence Type | Total Duration | Step Count | Step Overlap |
|--------------|----------------|------------|--------------|
| Tab Change | 300ms | 2 | 50% |
| Page Transition | 500-600ms | 2-3 | 30% |
| Modal Open | 400ms | 3 | 40% |
| Wizard Step | 400ms | 2 | 50% |
| Onboarding | 800-1200ms | 4-6 | 30% |
| Dramatic Reveal | 1000-1500ms | 5-8 | 40% |

## Implementation Patterns

```css
/* Staggered sequence */
.sequence-item {
  opacity: 0;
  transform: translateY(20px);
  animation: reveal 400ms ease-out forwards;
}

.sequence-item:nth-child(1) { animation-delay: 0ms; }
.sequence-item:nth-child(2) { animation-delay: 80ms; }
.sequence-item:nth-child(3) { animation-delay: 160ms; }
.sequence-item:nth-child(4) { animation-delay: 240ms; }

@keyframes reveal {
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

/* Page transition choreography */
.page-exit {
  animation: page-out 250ms ease-in forwards;
}

.page-enter {
  animation: page-in 300ms ease-out 200ms forwards;
}

@keyframes page-out {
  to { opacity: 0; transform: translateX(-30px); }
}

@keyframes page-in {
  from { opacity: 0; transform: translateX(30px); }
  to { opacity: 1; transform: translateX(0); }
}
```

## Sequence Orchestration Formula

```javascript
// Calculate stagger delays
const items = document.querySelectorAll('.sequence-item');
const totalDuration = 600; // ms
const overlap = 0.4; // 40% overlap

items.forEach((item, index) => {
  const stepDuration = totalDuration / items.length;
  const delay = index * stepDuration * (1 - overlap);
  item.style.animationDelay = `${delay}ms`;
});
```

## Key Rules

1. Overlap steps 30-50% - no gaps, no simultaneous starts
2. Total sequence under 800ms for functional UI
3. Test at 0.5x speed to verify choreography
4. Provide skip option for sequences over 500ms
5. `prefers-reduced-motion`: instant state change, no sequence

Overview

This skill helps design and orchestrate multi-step animation sequences using principles inspired by classic character animation. It provides timing guidelines, choreography patterns, and practical rules for page transitions, onboarding flows, wizards, and dramatic reveals. The goal is smooth, story-driven motion that feels natural and accessible.

How this skill works

The skill maps Disney-style principles to UI animation: squash & stretch, anticipation, staging, overlap, easing, arcs, secondary actions, and appeal. It gives concrete timing ranges, overlap percentages, CSS/JS patterns for staggering, and a simple formula to calculate delays so individual elements cascade instead of moving in unison. It also enforces accessibility rules like reduced-motion and skip options.

When to use it

  • Page-to-page transitions and route changes
  • Onboarding flows and tutorial step reveals
  • Multi-step wizards and form progression
  • Modal open/close sequences and dramatic reveals
  • Micro-interactions that need choreographed secondary actions

Best practices

  • Overlap steps 30–50% to avoid simultaneous starts and dead air
  • Keep total functional UI sequences under 800ms; use 1000–1500ms only for dramatic reveals
  • Favor subtlety on individual steps; make the overall sequence read as a single exaggerated motion
  • Stagger element starts by 50–100ms for organic follow-through and overlapping motion
  • Respect prefers-reduced-motion: collapse animations to instant state changes and provide a visible skip option for sequences over 500ms
  • Test choreography at 0.5x speed to verify timing, arcs, and secondary actions

Example use cases

  • Tab change: 300ms total, 2 steps, 50% overlap — quick slide + content fade
  • Page transition: 500–600ms, 2–3 steps — exit page, then enter with slight arc and easing
  • Modal open: 400ms, 3 steps — backdrop, dialog scale with squash/stretch, then inner content staggered
  • Onboarding flow: 800–1200ms, 4–6 steps — staged entrance, secondary actions, satisfying resolution
  • Dramatic reveal: 1000–1500ms, 5–8 steps — layered reveals with exaggerated timing and arcs

FAQ

How do I calculate staggered delays for N items?

Divide total sequence duration by item count to get stepDuration, then multiply index * stepDuration * (1 - overlap). Use 30–50% overlap (0.3–0.5) for natural cascades.

What to do for users who prefer reduced motion?

Respect prefers-reduced-motion by instantly setting final states rather than animating. Also offer a skip control for sequences longer than ~500ms.