Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
dylantarre avatar

Loading States

  • 359 installs
  • 68 repo stars
  • Updated December 30, 2025
  • dylantarre/animation-principles

loading-states is a frontend animation skill that maps Disney's 12 animation principles to spinners, skeletons, shimmer, and progress bars for developers building async fetch and save UX.

About

loading-states is an animation-principles skill that applies Disney's 12 animation principles to spinners, progress bars, skeleton screens, and shimmer effects while dashboards, searches, and saves wait on network responses. The skill prescribes immediate loading feedback on action, skeleton layouts that match final content staging, and subtle squash-and-stretch pulse on progress indicators around 0.98–1.02 scale so waits feel alive rather than frozen. Developers reach for loading-states when users anxiety spikes during slow API calls or blank panels before data arrives. The module sits in the dylantarre/animation-principles repo alongside character-appeal and transition-sequences, giving concrete motion guidance instead of generic spinner placement advice. Use it when implementing React, Vue, or mobile loading UI where perceived performance and spatial staging matter as much as raw latency.

  • Skeleton screens vs spinners decision guide
  • Perceived wait reduction techniques
  • Smooth handoff from placeholder to content
  • Avoid infinite loops and ambiguous stalls
  • Accessible loading announcements

Loading States by the numbers

  • 359 all-time installs (skills.sh)
  • Ranked #715 of 1,880 Design & UI/UX skills by installs in the Skillselion catalog
  • Data as of Aug 3, 2026 (Skillselion catalog sync)
npx skills add https://github.com/dylantarre/animation-principles --skill loading-states

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs359
repo stars68
Last updatedDecember 30, 2025
Repositorydylantarre/animation-principles

How do you animate loading states with Disney principles?

Design skeletons, spinners, and progress motion for async fetches so users understand wait time without anxiety during dashboards, searches, and saves.

Who is it for?

Frontend developers shipping dashboards, search UIs, or save flows where skeletons, spinners, and progress bars must reduce wait anxiety.

Skip if: Teams needing multi-step page transition choreography or character personality design without async loading UX.

When should I use this skill?

An async fetch, dashboard load, search, or save action needs spinners, skeletons, shimmer, or progress bars with principled motion.

What you get

Skeleton layouts, spinner timing rules, shimmer specs, and progress motion keyed to Disney's 12 principles.

  • skeleton screen spec
  • spinner and progress motion rules

By the numbers

  • Applies Disney's 12 animation principles to loading-state UX
  • Recommends 0.98–1.02 scale oscillation for progress indicator squash and stretch

Files

SKILL.mdMarkdownGitHub ↗

Loading State Animations

Apply Disney's 12 principles to communicate system activity.

Principle Application

Squash & Stretch: Progress indicators can pulse/breathe to show life. Slight scale oscillation (0.98-1.02).

Anticipation: Show loading state immediately on action. Don't wait for slow response to show spinner.

Staging: Loading indicators appear where content will be. Skeleton screens match final layout.

Straight Ahead vs Pose-to-Pose: Design loading as a sequence: instant indicator → progress → completion → content.

Follow Through & Overlapping: Loading fades as content enters. Overlap the transition by 100ms.

Slow In/Slow Out: Progress bars ease-in-out between known percentages. Indeterminate uses smooth oscillation.

Arcs: Circular spinners follow true circular paths. Avoid jerky rotation.

Secondary Action: Skeleton shimmer + subtle pulse. Multiple signals reinforce "loading."

Timing:

  • Show spinner after 200ms delay (avoid flash for fast loads)
  • Minimum display: 500ms (prevent jarring flash)
  • Skeleton shimmer cycle: 1500-2000ms

Exaggeration: Keep minimal - loading shouldn't distract, just reassure.

Solid Drawing: Skeletons should match content proportions. Wrong shapes break the illusion.

Appeal: Loading should feel optimistic, not tedious. Smooth motion suggests progress.

Timing Recommendations

Loading TypeAppear DelayMin DisplayAnimation Cycle
Spinner200ms500ms700-800ms
Progress Bar0ms-smooth fill
Skeleton0ms500ms1500ms shimmer
Button Spinner0ms400ms600ms
Full Page100ms800ms1000ms

Implementation Patterns

/* Skeleton shimmer */
.skeleton {
  background: linear-gradient(
    90deg,
    #e0e0e0 0%,
    #f0f0f0 50%,
    #e0e0e0 100%
  );
  background-size: 200% 100%;
  animation: shimmer 1500ms ease-in-out infinite;
}

@keyframes shimmer {
  0% { background-position: 200% 0; }
  100% { background-position: -200% 0; }
}

/* Spinner with smooth rotation */
.spinner {
  animation: spin 700ms linear infinite;
  opacity: 0;
  animation: fade-in 200ms 200ms ease-out forwards, spin 700ms linear infinite;
}

/* Progress bar with easing */
.progress-fill {
  transition: width 300ms cubic-bezier(0.4, 0, 0.2, 1);
}

Loading-to-Content Transition

.content-enter {
  animation: content-reveal 300ms ease-out forwards;
}

@keyframes content-reveal {
  from {
    opacity: 0;
    transform: translateY(10px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

Key Rules

1. Delay spinner appearance by 200ms to avoid flash 2. Keep loading visible minimum 500ms once shown 3. Skeleton shapes must match real content dimensions 4. Transition smoothly from loading to content - never pop 5. Respect prefers-reduced-motion - show static indicator instead

Related skills

How it compares

Use loading-states for async wait UX; pick transition-sequences when orchestrating multi-step page or wizard motion between stable views.

FAQ

Which Disney principles does loading-states apply?

loading-states maps Disney's 12 animation principles to loading UX, including squash and stretch on progress pulses, anticipation via immediate spinner display, and staging via skeleton screens placed where final content will render.

When should skeleton screens appear?

loading-states directs skeleton screens to appear where final content will land, matching layout staging, and to show loading immediately on user action rather than waiting for a slow network response to reveal a spinner.

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.