Back to Explore
GuideVibeFix editorialUpdated Nov 11, 2026

Don't Let Your Interface Feel Dead: Motion Design for Vibe Projects

Motion is not decoration — it is clues for the user's brain. This guide covers four duration tiers, three easing curves, the five places to animate first, reduced motion, and performance red lines, plus a half-page spec you can paste into your README.

A hand holding a phone showing an app folder on screen

Start with a very specific scene. A-Ling built a to-do app called Lime Todo — the product and person in this guide are fictional. After the first release, a user wrote in: "I tapped delete, the task just vanished, I thought it was a bug." She checked the code for hours. The delete logic was flawless. The problem was in the interface: the task disappeared instantly, with no transition, and the human brain never got the chance to connect "the thing I just tapped" with "the thing that is gone now."

Later she changed exactly one thing: when deleted, the task slides to the right while fading out, over 240 milliseconds. The complaints stopped. Not a single line of logic changed — only the way things disappear. That is the real place of motion in a vibe project: it is not makeup for the interface, it is clues handed to the user's brain.

" alt="A hand holding a phone showing an app folder on screen">

1. Motion is not decoration, it is information

When people hear "motion design" they think of showpieces: splash animations, particles, 3D flips. Those are fun to build and nearly useless for retention. The motion that actually matters does only three jobs, and each one maps to a moment where a real user gets confused.

The first job is explaining spatial relationships. Where a modal comes from, where a drawer slides back to, which direction a page exits — those trajectories tell the user "where you are now, and where that layer just went." Without trajectories, the interface is a pile of rectangles that appear and vanish out of nowhere, and the user has to re-orient on every screen.

The second job is establishing cause and effect. You tap a button, the button shrinks a little and changes color, and only then are you sure "my action was received." Without that beat of feedback, users tap again — and that is how you get duplicate submissions, duplicate orders, duplicate messages. A lot of so-called "double-submit bugs" are really missing-feedback bugs.

The third job is covering waiting. Before the data arrives, a skeleton screen or a gentle fade-in is far more dignified than a blank white screen. How long users tolerate waiting depends on whether something is moving while they wait — that is an honest psychological fact, not mysticism.

So there is a simple rule for prioritizing motion: build first the motion without which users get confused, mis-tap, or think something broke. Decorative motion goes last. That ordering matters most for a solo team, because motion is one of the few places where a little work buys a big improvement — and one of the few where overdoing it instantly backfires.

Flip it around and the three ways a motionless product dies are just as common. The first is the "teleport" interface: you tap, the whole page swaps instantly, and you have no idea whether your action worked or which layer you are on — you re-read the header to find your bearings. The second is the "ghost action": you tap delete, send, or pay, nothing visibly happens, and you are left guessing; guess wrong and you do it twice. The third is the "white-screen wait": you open a detail page, stare at white for two seconds, and the whole page suddenly pops in — during those two seconds you are already wondering if the network died. None of these is a functionality problem. All three are missing information, and motion is what fills the gap.

2. Four duration tiers: the smaller the move, the faster it should be

The most common motion bug is not absence, it is slowness. A modal that floats in over 800 milliseconds is torture when a user opens and closes it dozens of times a day. And a celebration animation given only 150 milliseconds is invisible — work wasted.

I use a four-tier table, sorted by the size of the move, written straight into the project spec so nobody has to improvise each time:

Micro-feedback — a button press, a toggle flip, a like turning red — 80–150 ms. This tier has to feel instant; any slower and it reads as lag. UI transitions — a modal appearing, a drawer sliding out, a list expanding — 200–300 ms. This is the most-used tier in daily use, and the easiest one to make too slow. Page switches — route changes, tab switches — 300–500 ms, enough to give a sense of direction, not enough to drag. Celebration and emphasis — task completed, achievement unlocked, an empty-state illustration arriving — 500–900 ms. This is the only tier allowed to be slow, because the user is in no hurry at that moment.

" alt="Bar chart of four motion duration tiers: micro-feedback 80–150 ms, UI transitions 200–300 ms, page switches 300–500 ms, celebration and emphasis 500–900 ms">

The table has a second use: it is a ruler for cutting motion. In review, anything over its tier's ceiling gets cut, and nobody can argue from vibes that "this animation just deserves to be slower." Feelings are the most expensive review criterion there is; save them where they count.

One more detail: entrances and exits should not share a duration. Something appearing can be a touch slower, so the user sees where it came from; something disappearing should be faster, because the user is done with it and it is only in the way. Lime Todo's delete animation slides out over 240 ms, while its add animation fades in over just 180 ms — deleting deserves more time than adding, because deleting by mistake costs more.

3. Picking easing: three curves are enough

Easing is the part of motion most prone to mysticism. You can find dozens of curve names online. For a solo team, three are enough.

The first is ease-out: fast start, slow finish. Use it for things entering: the start is crisp so the user sees change immediately, and the slow stop looks stable. Modals, toast bars, expanding menus — ease-out by default. The second is ease-in: slow start, fast finish. Use it for things leaving: a slow goodbye at the start, a clean disappearance at the end. Do not swap them — an entrance on ease-in makes the interface feel sluggish, and users tap again thinking the first tap missed. The third is spring, with a little bounce. Save it for places that should feel alive: a like button's heartbeat, a dragged item snapping back, a toggle finishing its travel. At most one or two springs per page; more than that feels frivolous, like every button is flirting with you.

And one iron rule: the same kind of move always uses the same curve. Every modal ease-out, every exit ease-in. Users build expectations through repetition; if modals enter differently every time, no expectation ever forms. A motion spec is like a color spec — consistency first, beauty second.

On concrete values, do not agonize: the CSS defaults for ease-out and ease-in work fine. If you want to be more deliberate, use cubic-bezier(0.2, 0, 0, 1) for entrances and cubic-bezier(0.4, 0, 1, 1) for exits, and leave spring parameters to a ready-made preset — hand-tuning damping and stiffness almost always produces something either dead stiff or wobbling forever. Trust the defaults over your own hand.

One last judgment call that gets overlooked: not every change needs motion. Pure text updates — a number going from 12 to 13, a status flipping from "pending" to "done" — are cleaner when swapped directly. Motion serves three cases only: something moved, something changed layers, or something appeared or disappeared. Animating anything else is fussing in a place the user already understood.

4. Which five to build first: copy this order

If you have no motion at all right now, do not try to add everything at once. Work down this list; each item pays off the moment it lands:

First, button feedback. On press, scale to 0.96 and opacity to 0.9, over 80–150 ms. Cheapest to build, biggest return, and it cures double-tapping. Two implementation notes: bind the feedback to pointerdown, not click — feedback on release is half a beat late; and scale with transform: scale, never width and height, or the whole layout will shudder. Second, list add and remove. New items fade in from above, deleted items slide out to one side, 200–300 ms. This is the change that saved Lime Todo, and no product with a list escapes it. One detail deserves its own sentence: play the slide-out animation first, and only remove the item from the data after the animation finishes. Delete the data first and the list jumps up a row while the animation is still running — motion wasted, order reversed, result completely different. Third, page transitions. Give routing a direction: forward slides left, back slides right, 300–500 ms. The user instantly knows whether they are going deeper or coming back — a feeling no text navigation can deliver. Fourth, loading feedback. Before data arrives, show a skeleton screen with a faint breathing shimmer, not a spinner — a spinner says "waiting," a skeleton says "waiting for what." And the skeleton's shape has to match the real content: grey bars for a list page, a title plus paragraphs for a detail page; a mismatched skeleton is worse than none. Fifth, completion celebration. When a task completes or a form submits, give it a small 500–900 ms celebration: the checkmark draws itself, the number ticks up. Never a full-screen confetti blast — that is pestering the user, not celebrating. How restrained the celebration is decides whether users find it charming: things that fire dozens of times a day should be feather-light; only a rare achievement earns something slightly grander.

Once these five are in place, the product's motion skeleton stands. The rest — splash animations, drifting empty-state illustrations — belongs in the "when there's time" tier.

5. Reduced motion: not everyone likes moving

Some users get dizzy or nauseous from motion, and it can trigger vestibular reactions. That is not fussiness, it is a real physiological response. So motion design needs an escape hatch: detect prefers-reduced-motion and, when it is on, switch off all non-essential motion, keeping only the shortest fade — or nothing at all.

It is not hard to implement: one media query in the global styles that crushes every animation duration to 0.01 ms, which is effectively instant. Write this rule at the start of the project, not after the first complaint — the people who complain are the minority; the ones who quietly leave are invisible to you forever.

Two more groups deserve care: people on old phones and people on bad networks. However beautiful the motion, a dropped frame turns it into a penalty. So before shipping, test on a three-year-old Android phone and simplify or cut anything that stutters. An animation that is silky on a top-spec Mac can be a slideshow in your user's hand.

6. The performance red line: move only two things

The number-one cause of motion jank is animating the wrong property. Remember the red line: animate only transform (translate, scale, rotate) and opacity. The browser can hand both to the GPU without triggering reflow, so they almost never drop frames.

Animating width, height, top, left, or margin, by contrast, can trigger layout and paint on every frame — a long list will stutter immediately. AI-generated code loves animating these properties because it reads intuitively — if you see a modal sliding in with top going from -100px, do not hesitate: rewrite it as transform: translateY. Another common trap is animating too many elements at once. A dozen list items fading in with staggered delays looks sophisticated, and on a low-end phone it is a disaster. Staggered entrances belong on a handful of above-the-fold elements only, with total time under 500 ms.

Checking performance needs no professional tooling: open the browser devtools performance panel, record one interaction, and look for long tasks and dropped frames. Or the cruder method: test on an old phone — your eyes are the best performance tool there is.

A-Ling walked straight into the stagger trap: Lime Todo's home list had a dozen items, and she gave each a 40 ms staggered fade-in. On her own computer it looked elegant. On a friend's three-year-old Android it unfolded like dominoes, the last item taking nearly a second to appear. The fix was simple: stagger only the first five above-the-fold items, cap total time at 300 ms, and let the rest appear directly. Elegance is the first thing sacrificed on a low-end phone — and it should be, because users want a usable list, not a dancing one.

7. Write motion into the spec, not into your head

What motion fears most is not scarcity but everyone improvising by feel. Today one person gives a modal 300 ms ease-out, tomorrow the AI adds a 600 ms linear fade, the day after a bouncy drawer appears. Three months later the product has a dozen "styles," and users cannot say what is wrong, only that it feels unpolished.

The fix is turning the four-tier table from section two into constants in code, not a line in a document. Define four duration tokens — fast 120 ms, standard 240 ms, slow 400 ms, celebration 700 ms — and three easing tokens: ease-out for entrances, ease-in for exits, one standard spring preset. Every animation in the product may only reference these seven tokens, never a hand-written number. When AI writes code for the project, put this rule in the project's development conventions so it references the tokens every time — otherwise it will invent a new number on each pass, and every one will be different.

The spec should also state two boundaries: what may move and what may not. Transform and opacity may move; properties that trigger reflow may not. Springs are allowed for likes, toggles, and drag snap-back — three cases — and forbidden for modals, page switches, and form feedback. With the boundaries written down, review stops being an argument about taste and becomes a check against the rules.

The whole spec fits on half a page: four durations, three curves, five must-builds, two red lines. Paste it into the project README, and anyone — including you, coming back to the code three months later — can read it at a glance. A motion spec is like a code spec: its value is not in how complete it is, but in being followed every time.

8. How to review motion: record it, play it back slow

You cannot judge motion by staring at the screen — your eyes get fooled by the feeling of smoothness. The crude method that actually works: record the interaction on video, then play it back at 0.25x. At quarter speed nothing hides: whether the modal flashes before it starts moving, whether the rows below a deleted item jump, whether a button misses one frame on press, whether two animations race each other.

Review with three questions: first, does this animation explain where things came from and where they went; second, would removing it leave users confused or mis-tapping; third, will it drop frames on an old phone. If any question has no good answer, the animation is suspect.

One more review habit: after every motion change, look at the product once with reduced motion on. Many teams discover on their first try that without animation their product falls apart: modals pasted onto the middle of the screen, page switches like teleports, deletions with no warning at all. Reduced-motion mode is the best mirror there is — it forces you to admit which information motion was carrying and which parts stand on layout alone. Where layout cannot stand on its own, fixing the layout matters more than adding animation.

9. Pre-launch checklist

Before shipping, spend ten minutes walking this list: does every button give press feedback; do list add and remove have transitions; do page switches have direction; is there a skeleton screen instead of a white screen while loading; is there a light celebration for completed actions; is the whole site quiet with reduced motion on; did you test on an old phone for dropped frames; do all durations match the four-tier table.

Keep the anti-patterns next to it and fix them on sight: a modal entrance longer than a second; a button with no feedback; a full-screen confetti celebration; a homepage where every element staggers in one by one; animation driven by top and left; decorative animation still spinning with reduced motion on.

One honest note to close: motion is where a vibe project most easily looks professional — and where it most easily gives away that it was one-shotted by AI. AI-generated interfaces usually fall into one of two extremes: no motion at all, dead on arrival; or default-easing fade-ins everywhere, like a slide deck. Run through the four-tier table and the five-item list in this guide once, and the product immediately gains the feel of something somebody actually tuned. Users cannot describe that feeling. But they can feel it.

If you can change only one thing today, change button feedback. Two lines of styles, one afternoon of testing, and an entire category of double-tap complaints disappears on the spot. That is how motion compounds: one place at a time, tested once each, and three months later you look back and the product feels like a different person.

Views 4Comments 0

Comments (0)

ME
0/1000
Loading comments...
Browse projectsPublish your project

Related articles

Real photo: a laptop, tablet, and phone on a wooden table showing the same green-leaf website, the phone view with navigation in one column, a potted plant nearby
Guide
Squashed on phones? Responsive layout and media queries, explained plainly

One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.

Mobile AppsDesign ExperienceFrontend Engineering
Real photo: a bank of light gray metal filing cabinets with one drawer pulled open, revealing rows of hanging file folders inside
Guide
A real database inside the browser: IndexedDB local storage, explained plainly

localStorage only stores strings and has no indexes. IndexedDB is a real database in the browser: structured data, far larger capacity, indexes, and transactions. Following MDN's Using IndexedDB, IDBDatabase, and IDBObjectStore: the five-step routine, opening, upgrades, keys, indexes, transactions, add versus put, get, cursors, ranges, and multi-tab upgrades.

Tool TipsData WorkflowsFrontend Engineering
Real photo: hands typing on a MacBook Pro showing JavaScript code that changes HTML content, with a white mouse, papers, and binders on a white desk
Guide
Functions without the confusion: JavaScript functions, parameters, and arrow functions, explained plainly

You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.

Tool TipsFrontend EngineeringAI Coding