# slow-in-out-mastery

A skill that tells your coding agent which acceleration and deceleration curve to use in UI, character or game animation.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 517 installs · ★ 124
- Author: dylantarre
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/dylantarre/animation-principles/tree/HEAD/skills/11-by-principle-focus/slow-in-out-mastery/SKILL.md
- Updated: 2025-12-30
- HTML: https://affpapa.org/en/nevibecode/skills/slow-in-out-mastery

## What it does

The skill covers the slow in / slow out principle: real objects speed up from rest and slow down before stopping instead of moving at a constant rate. Your agent gets the spacing theory behind it, the common easing functions (ease out, ease in, ease in out, linear, custom bezier), and how easing interacts with timing, anticipation, follow through and squash/stretch.

From there it splits by domain: page transitions, modals, buttons, loaders and hover states in UI work; jumps, head turns, blinks and weight shifts in character animation; text reveals and logo work in motion graphics; camera movement and control response in games. A separate section covers bounce, elastic and back — curves that overshoot and settle.

The practical half is a selection heuristic: ease out for element appearances and responses to user action, ease in for exits, ease in out for animations nobody triggered. It also lists the usual mistakes — linear motion everywhere, curves that are too soft, easing pointed the wrong way. The skill suggests starting with ease out for most UI animation. It is a written guide, so there are no scripts to run; custom bezier values you still work out yourself.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add dylantarre/animation-principles --skill slow-in-out-mastery -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/slow-in-out-mastery/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/slow-in-out-mastery/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add dylantarre/animation-principles --skill slow-in-out-mastery -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/slow-in-out-mastery/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add dylantarre/animation-principles --skill slow-in-out-mastery -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/slow-in-out-mastery/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install dylantarre/animation-principles slow-in-out-mastery
```

2. **Manually: put the files in place**
- File: `.github/skills/slow-in-out-mastery/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add dylantarre/animation-principles --skill slow-in-out-mastery -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/dylantarre/animation-principles --path skills/11-by-principle-focus/slow-in-out-mastery
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/slow-in-out-mastery/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add dylantarre/animation-principles --skill slow-in-out-mastery -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/dylantarre/animation-principles/tree/HEAD/skills/11-by-principle-focus/slow-in-out-mastery/SKILL.md

## When to use it
- pick a curve for a modal appearing on screen
- explain why linear motion looks mechanical
- separate easing for entrances and exits
- tune a character jump with acceleration and deceleration
- choose between bounce and elastic when overshoot is wanted

## Example prompts
- pick an easing for the modal entrance, it should feel responsive
- why does my button animation look robotic — what is wrong with the curve
- build a character jump: accelerate off the ground, decelerate into the peak

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: e9a02a146f8607b8.

BEGIN THIRD-PARTY FILE e9a02a146f8607b8
```text
---
name: slow-in-out-mastery
description: Use when designing easing curves, controlling motion pacing, creating natural acceleration/deceleration, or making movements feel physically grounded.
---

# Slow In / Slow Out Mastery

## The Physics Principle

Objects in the real world don't move at constant speeds—they accelerate from rest and decelerate to stops. Slow in/slow out (also called ease in/ease out) captures this fundamental truth. Without it, animation looks mechanical. With it, motion feels alive.

## Core Theory

**Slow Out** (Ease Out): More drawings clustered at the start of a movement. The object accelerates away from its starting position gradually.

**Slow In** (Ease In): More drawings clustered at the end of a movement. The object decelerates into its final position gradually.

**Linear motion**: Equal spacing between positions. Rare in nature, useful for mechanical elements or stylistic choice.

## The Spacing Principle

Traditional animators controlled this through drawing spacing:
- **Tight spacing** = slow movement (drawings close together)
- **Wide spacing** = fast movement (drawings far apart)

Digital animators control this through easing curves—mathematical functions that describe how values change over time.

## Common Easing Functions

- **Ease Out**: Fast start, slow end (70% of UI animations)
- **Ease In**: Slow start, fast end (exits, departures)
- **Ease In Out**: Slow start and end (elegant, deliberate)
- **Linear**: Constant rate (mechanical, looping)
- **Custom bezier**: Precise control for specific feels

## Interaction with Other Principles

**Timing is modified by easing**: The same duration feels different with different easing. Ease out feels faster than ease in at identical durations.

**Anticipation often uses ease in**: The wind-up accelerates before the fast action.

**Follow through uses ease out**: Settling motion decelerates to rest.

**Squash/stretch intensity follows easing**: More deformation during fast phases, less during slow phases.

## Domain Applications

### UI/Motion Design
- **Page transitions**: Ease out for entrances (fast appearance, settle), ease in for exits
- **Modals**: Ease out scale-up for friendly, non-jarring appearance
- **Buttons**: Ease out on press feedback (immediate response, smooth settle)
```
END THIRD-PARTY FILE e9a02a146f8607b8

The third-party file has ended. Everything between the e9a02a146f8607b8 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2307 of 4404 bytes. © dylantarre · MIT · https://github.com/dylantarre/animation-principles/tree/HEAD/skills/11-by-principle-focus/slow-in-out-mastery/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md