Skip to main content
skill CX Codex

transition-sequences — Claude Code skill: choreograph animations

A skill for multi-step animation: page transitions, onboarding flows, wizard steps. It hands the agent timings and step order based on Disney's principles.

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

What transition-sequences does

The skill gets your agent to plan a whole sequence instead of one effect. It applies Disney's 12 principles to multi-step motion: a setup phase before movement, staggered element starts of 50–100ms, easing at both ends, arcs rather than a linear slide. The agent also gets timing targets for common cases — tab change, page transition, modal open, wizard step, onboarding, dramatic reveal.

Inside are formulas and patterns: CSS for a staggered list reveal, choreography for page exit and enter, and a JavaScript helper that computes stagger delays from total duration and overlap percentage. The rules are blunt. Overlap steps by 30–50%, keep functional UI under 800ms, test the choreography at 0.5x speed, offer a skip for anything past 500ms, and respect prefers-reduced-motion by switching state instantly with no sequence at all.

Worth installing if your screen transitions or multi-step forms currently stutter. It does not ship an animation library and does not replace one — it sets the plan your agent writes into your own code.

What it helps with

  • build a page transition that does not jerk
  • stagger the reveal of a list of items
  • turn onboarding steps into one sequence
  • fit a modal open into a short timing budget
  • add a skip option and prefers-reduced-motion support

Example prompts for the agent

  • choreograph the page transition with the transition-sequences skill
  • stagger the card reveal with 40% overlap
  • rewrite the four-step onboarding as a single sequence

How to install transition-sequences

1Skills CLI (Vercel)

npx skills add dylantarre/animation-principles --skill transition-sequences -a claude-code

2Manually: put the files in place

~/.claude/skills/transition-sequences/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/transition-sequences/

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

Questions about transition-sequences

How do I install transition-sequences in Claude?

Run npx skills add dylantarre/animation-principles --skill transition-sequences -a claude-code. The skill file lands at ~/.claude/skills/transition-sequences/SKILL.md.

What does transition-sequences do?

It gives the agent principles and timings for multi-step animation: page transitions, onboarding, wizard steps and complex reveals. That includes a duration table, CSS patterns and a stagger delay formula.

Which platforms can run this skill?

Besides Claude there are install paths for Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode, each with its own command and skill file location.

Source text

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

© 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