Skip to main content
skill CX Codex

gsap-router — Claude Code skill: what it does, how to install

The gsap-router Claude Code skill routes GSAP animation requests to focused skills. It matches the task to core animation, sequencing, scroll effects, or React integration.

MIT 102 installs ★ 9 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Bbeierle12/Skill-MCP-Claude --skill gsap-router -a claude-code
Open on GitHub

What gsap-router does

gsap-router selects from four GSAP skills: gsap-fundamentals, gsap-sequencing, gsap-scrolltrigger, and gsap-react. It matches signals in a request, such as timeline, ScrollTrigger, or useGSAP, then points to the relevant instructions before implementation.

Some projects call for a combination. A pinned scroll section can use ScrollTrigger with sequencing; a React component animation can combine core techniques with React integration. When the request is unclear, the router starts with gsap-fundamentals. If no framework is named, it assumes vanilla JS.

What it helps with

  • choose a skill for a basic element animation
  • build a sequence from multiple animations
  • connect an animation to page scrolling
  • select skills for a React component animation

Example prompts for the agent

  • Animate this element so it fades in when the page loads.
  • Create a pinned section with an animation tied to scrolling.
  • Choose GSAP skills for animating a React component.

How to install gsap-router

1Skills CLI (Vercel)

npx skills add Bbeierle12/Skill-MCP-Claude --skill gsap-router -a claude-code

2Manually: put the files in place

~/.claude/skills/gsap-router/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/gsap-router/

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

Questions about gsap-router

How do I install gsap-router in Claude Code?

Run npx skills add Bbeierle12/Skill-MCP-Claude --skill gsap-router -a claude-code. The skill file is placed at ~/.claude/skills/gsap-router/SKILL.md.

What does gsap-router do?

It routes GSAP tasks to one or more of four skills covering animation basics, sequencing, ScrollTrigger, and React.

How does gsap-router choose which skills to use?

It matches signals in the request to the animation type and framework. For unclear requests, it starts with gsap-fundamentals.

Source text

SKILL.md · MIT
---
name: gsap-router
description: Router for GSAP animation domain. Use when implementing animations with GreenSock Animation Platform including tweens, timelines, scroll-based animations, or React integration. Routes to 4 specialized skills for fundamentals, sequencing, ScrollTrigger, and React patterns.
---

# GSAP Router

Routes to 4 specialized skills based on animation requirements.

## Routing Protocol

1. **Classify** — Identify animation type from user request
2. **Match** — Apply signal matching rules below
3. **Combine** — Production animations often need 2-3 skills together
4. **Load** — Read matched SKILL.md files before implementation

## Quick Route

### Tier 1: Core (Start Here)
| Need | Skill | Signals |
|------|-------|---------|
| Basic animations, easing | `gsap-fundamentals` | tween, animate, ease, from, to, duration, delay |
| Complex sequences | `gsap-sequencing` | timeline, sequence, orchestrate, labels, callbacks |
| Scroll animations | `gsap-scrolltrigger` | scroll, pin, scrub, parallax, reveal, sticky |
| React integration | `gsap-react` | React, useGSAP, ref, hook, cleanup, context |

## Signal Matching

### Primary Signals

**gsap-fundamentals**:
- "animate", "tween", "transition"
- "ease", "easing", "timing"
- "from", "to", "fromTo"
- "duration", "delay", "repeat"
- "stagger", "properties"

**gsap-sequencing**:
- "timeline", "sequence", "orchestrate"
- "labels", "callbacks", "nested"
- "position parameter", "overlap"
- "complex animation", "choreography"
- "play", "pause", "reverse", "seek"

**gsap-scrolltrigger**:
- "scroll", "ScrollTrigger"
- "pin", "sticky", "fixed"
- "scrub", "parallax"
- "reveal on scroll", "snap"
- "progress indicator"

**gsap-react**:
- "React", "component"
- "useGSAP", "useRef", "hook"
- "cleanup", "context"
- "event handler", "state"

### Confidence Scoring

- **High (3+ signals)** — Route directly to matched skill
- **Medium (1-2 signals)** — Route with fundamentals as foundation
- **Low (0 signals)** — Start with `gsap-fundamentals`

## Common Combinations

### Basic Animation (1 skill)
```
gsap-fundamentals → Tweens, easing, basic properties
```

### React Component Animation (2 skills)
```
gsap-fundamentals → Animation principles, easing
gsap-react → Hook patterns, cleanup, refs
```

### Scroll-Based Experience (3 skills)
```
gsap-scrolltrigger → Scroll triggers, pinning
gsap-sequencing → Timeline for pinned sections
gsap-fundamentals → Individual animations
```

### Full Production (3-4 skills)
```
gsap-fundamentals → Core animations
gsap-sequencing → Complex orchestration
gsap-react → Framework integration
gsap-scrolltrigger → Scroll interactions (if needed)
```

## Decision Table

| Framework | Animation Type | Complexity | Route To |
|-----------|---------------|------------|----------|
| Vanilla JS | Simple | Low | fundamentals |
| Vanilla JS | Sequenced | Medium | fundamentals + sequencing |
| Vanilla JS | Scroll-based | Medium | fundamentals + scrolltrigger |
| React | Simple | Low | fundamentals + react |
| React | Complex | High | All four skills |
| React | Scroll | Medium | react + scrolltrigger |

## Animation Categories

### Motion Type → Skill Mapping

| Animation Type | Primary Skill | Supporting Skill |
|----------------|---------------|------------------|
| Fade in/out | `gsap-fundamentals` | - |
| Slide/move | `gsap-fundamentals` | - |
| Scale/rotate | `gsap-fundamentals` | - |
| Stagger | `gsap-fundamentals` | - |
| Page transitions | `gsap-sequencing` | fundamentals |
| Orchestrated reveals | `gsap-sequencing` | fundamentals |
| Scroll reveals | `gsap-scrolltrigger` | fundamentals |
| Parallax | `gsap-scrolltrigger` | - |
| Pinned sections | `gsap-scrolltrigger` | sequencing |
| React animations | `gsap-react` | fundamentals |
| React + scroll | `gsap-react` | scrolltrigger |

## Integration with Other Domains

### With R3F (r3f-*)
```
r3f-fundamentals → 3D scene setup
gsap-fundamentals → Object property animation
gsap-sequencing → Camera movements, scene transitions
```
GSAP animates Three.js object properties via `onUpdate`.

### With Post-Processing (postfx-*)
```
postfx-composer → Effect setup
gsap-fundamentals → Animate effect parameters
gsap-sequencing → Transition between effect states
```
GSAP drives effect intensity, colors, etc.

### With Audio (audio-*)
```
audio-playback → Music timing
gsap-sequencing → Sync animations to audio cues
gsap-fundamentals → Audio-reactive property changes
```
Timeline callbacks sync with audio events.

### With Particles (particles-*)
```
particles-systems → Particle emitters
gsap-fundamentals → Animate emitter properties
gsap-sequencing → Particle burst sequences
```

## Workflow Patterns

### Page Load Animation
```
1. gsap-fundamentals → Understand tweens, easing
2. gsap-sequencing → Build entrance timeline
3. gsap-react → Integrate with React (if applicable)
```

### Scroll Experience
```
1. gsap-scrolltrigger → Set up triggers, pins
2. gsap-sequencing → Build scrubbed timelines
3. gsap-fundamentals → Individual animation properties
```

### Interactive UI
```
1. gsap-fundamentals → Hover, click animations
2. gsap-react → Event handlers, cleanup
3. gsap-sequencing → Complex interaction sequences
```

## Temporal Collapse Stack

For the New Year countdown project:
```
gsap-fundamentals → Digit animations, pulse effects, easing
gsap-sequencing → Countdown sequence, final moment orchestration
gsap-react → Component integration, cleanup
```

Key animations:
- Digit flip on time change
- Pulse/glow intensity over time
- Final countdown dramatic sequence
- Celebration reveal at zero

## Quick Reference

### Task → Skills

| Task | Primary | Secondary |
|------|---------|-----------|
| "Animate this element" | fundamentals | - |
| "Create entrance animation" | fundamentals | react |
| "Build page transition" | sequencing | fundamentals |
| "Animate on scroll" | scrolltrigger | fundamentals |
| "React component animation" | react | fundamentals |
| "Pinned scroll section" | scrolltrigger | sequencing |
| "Complex animation sequence" | sequencing | fundamentals |
| "Staggered list animation" | fundamentals | react |

### Easing Quick Reference

| Feel | Ease |
|------|------|
| Snappy UI | `power2.out` |
| Smooth entrance | `power3.out` |
| Playful bounce | `back.out(1.7)` |
| Springy | `elastic.out` |
| Ball drop | `bounce.out` |
| Linear/mechanical | `none` |

## Fallback Behavior

- **No framework stated** → Assume vanilla JS, start with `gsap-fundamentals`
- **React mentioned** → Add `gsap-react` to combination
- **Scroll mentioned** → Add `gsap-scrolltrigger`
- **"Complex" or "sequence"** → Add `gsap-sequencing`
- **Unclear requirements** → Start with `gsap-fundamentals`

## Performance Priority

When performance is critical:
1. `gsap-fundamentals` — Use transforms, avoid layout properties
2. `gsap-react` — Proper cleanup prevents memory leaks
3. `gsap-scrolltrigger` — Use `scrub` wisely, batch updates
4. `gsap-sequencing` — Reuse timelines, don't recreate

© Bbeierle12 · MIT · Bbeierle12/Skill-MCP-Claude

Similar skills

All skills for Frontend and UI →

From the same set19

The whole set →
software-architecture software-architecture — a skill that walks the agent through SOLID and Clean Architecture, with a bad and a good version of the same TypeScript code for each principle. CX Codex +1 150installs particles-physics particles-physics is a Claude Code skill that adds forces and velocity fields to particle motion in scenes with gravity, wind, attractors or turbulence. CX Codex +1 134installs r3f-fundamentals r3f-fundamentals guides setup of React Three Fiber scenes, Canvas configuration, lighting, camera rigs, and render loop logic in declarative JSX. CX Codex +1 125installs shader-noise shader-noise is a Claude Code skill with GLSL noise algorithms for generating organic textures, terrain, clouds, fire, and cellular patterns in shaders. CX Codex +1 121installs form-ux-patterns The form-ux-patterns skill guides the design of complex forms with grouped fields, step-by-step flows, and conditional inputs. Use it for checkout or onboarding experiences. CX Codex +1 120installs audio-reactive audio-reactive maps audio analysis data to visual parameters, CSS transforms, and 3D scenes. CX Codex +1 108installs postfx-effects postfx-effects is a Claude Code skill with post-processing recipes for React Three Fiber scenes, including depth of field, chromatic aberration, vignette, and film grain. CX Codex +1 106installs r3f-performance The r3f-performance Claude Code skill covers ways to improve React Three Fiber rendering. It activates for large 3D scenes or when investigating frame-rate drops. CX Codex +1 100installs

Project sponsors

Companies that keep this analytics open