---
name: premium-app-feel
description: Make an app feel premium and treat people well, using app psychology. Use when designing, building or reviewing any app screen or flow (onboarding, forms, checkout, settings, lists, empty states, errors, loading and waits, progress, success screens, notifications, streaks, rewards, paywalls), or when asked to "make it feel premium", "polish the UX", "make it feel expensive", "improve retention" or "review this flow". Covers anticipating needs, choice overload, consistency and one loud thing, a motion budget, peak-end moments, honest waits, goal gradient, empty and error states that never dead-end, and where engagement hooks become traps.
---

# Premium app feel

Apps feel expensive because of many small decisions, not because of a colour or a font. This skill
turns those decisions into rules you can follow while you design and build, and a checklist to
review against before you call a screen done.

Source: [Why some apps feel expensive](https://mbuilds.studio/writing/apps-that-feel-expensive) by
Meer Habib, built on Wyatt Feaster's videos on premium app design and app psychology. Free to use
and adapt.

## How to use this skill

1. **Name the moment.** For each screen or flow, write one line: what the person came to do, and
   how often they do it (every few seconds, several times a day, daily, now and then, once).
   Frequency decides how much motion and ceremony the moment gets.
2. **Walk sections 1 to 8** and apply every rule that fits. Prefer the platform's own components
   and transitions over custom ones.
3. **Run the checklist** at the end. When you report back, list what you changed, one line per rule.

## 1. Anticipate

People feel looked after when the next step is already half done.

- Prefill everything the app already knows: the last address, the account's phone and email,
  today's date, their currency, their previous choice.
- Preselect the most likely option and say why in a word or two ("your usual", "recommended").
- Show one recommendation first. Put the rest behind "Other times", "See all" or a search.
- More than about seven comparable options: group them, add a filter or search, or cut the ones
  nobody picks. Choice overload hits hardest when options are hard to compare.
- Collapse forms into one input where you can: a sentence the app parses, a photo it reads. Always
  show what was filled in and ask the person to review it before saving.
- In quick-entry flows, focus the first field on open with the right keyboard (numeric for
  amounts, email for email).

Avoid: blank forms for data the app has; twelve equal options with none suggested; asking the same
question twice in one flow.

## 2. A quiet room, one loud thing

Consistency is invisible when it's right and feels cheap when it's off. It is also what lets one
thing stand out (the von Restorff effect): if everything shouts, nothing does.

- One icon family and one style (all outline or all filled), one stroke width.
- One radius scale, one type scale, one spacing scale. Use design tokens; never hand-tune a value
  for one screen. If something looks wrong, fix the token so every screen improves.
- One press behaviour for every tappable thing, and at most two springs (small moves, big moves).
- Each screen gets exactly one loud element: the hero content, the primary action or the
  recommended plan. Everything else stays neutral.
- Show selection by inversion or with the single accent colour, not with new colours.
- When reviewing a diff, list every distinct radius, font size and colour it introduces and flag
  any value that isn't a token.

## 3. Motion budget

The more often something happens, the less it should move. Animate to give feedback and keep
people oriented, never to decorate.

| How often | Examples | Motion |
| --- | --- | --- |
| Every few seconds | typing, scrolling, entering a card number | none |
| Dozens of times a day | toggles, tab switches | about 100 to 200 ms, no bounce |
| A few times a day | sheets, pushing a screen | about 250 to 400 ms, platform transitions |
| Daily | saving, finishing a task | up to about 600 ms, one small acknowledgement |
| Now and then | a booking confirmed, a goal reached | up to about 1.2 s |
| Once | first success, a real milestone | up to about 2 s, and skippable |

- Never block input while something animates. Never animate inside critical paths: payment entry,
  sign in, error recovery.
- Respect Reduce Motion: swap movement for a short fade. React Native: Reanimated's
  `useReducedMotion()` or `AccessibilityInfo.isReduceMotionEnabled()`. SwiftUI:
  `@Environment(\.accessibilityReduceMotion)`. Web: `prefers-reduced-motion`.

## 4. The peak and the end

People judge an experience by its most intense moment and by how it ended (the peak-end rule).

- In every flow, mark three moments: the **peak** (where the value lands), the **end** (the last
  screen) and the **worst moment** (an error, a wait, a paywall). Design the peak and the end first,
  then soften the worst moment. One bad moment can become the whole memory.
- Success screens say what was achieved in the person's terms and offer one next step.
- **Delight** answers something the person deliberately did, plays once and never loops. Nothing
  celebrates on every visit.
- **Discovery:** leave one good surprise for people who keep going (a monthly recap, a collectible,
  a postcard after a booking). Never announce it, never require it.

## 5. Waits: show real work

Effort people can see feels like value (the labour illusion). Use it honestly.

- If something usually finishes in under about 300 ms, show nothing at all. A spinner that flashes
  feels slower than no spinner.
- If you know the layout that's coming, show a skeleton of it.
- For waits over about a second, say what is happening in plain words, step by step, tied to the
  real work wherever possible.
- **Never add artificial delay.** Never let a progress bar reach 100% before the real result is
  back. If step labels have to run on a timer, cap the bar below 100% until the work is done.
- When refreshing, keep the old content on screen and update it in place.
- At the end of the wait, hand over clearly: what was filled in or found, and what to check.
- Pace the in-between moments on purpose. A pause in a sensitive flow can be a calm screen
  ("Take your time"), not dead air.

## 6. Momentum

People speed up as they get closer to a goal (the goal gradient), and a head start makes them more
likely to finish.

- Show the distance, not just the task: "2 of 5 done", "Step 1 of 4", "135 XP to the next level",
  never only "Complete your profile".
- Count steps the person really completed (creating the account, choosing a currency) as progress.
  Never fake progress they didn't make.
- Open loops (unfinished things that stay on the mind) are for the person's own goals: a draft they
  started, a lesson they chose. Never invent badges or counts to pull them back.

## 7. Never a dead end

Every empty screen and every error points somewhere.

**Empty states** come in three kinds, each with its own words:

- First use: what will live here, and one primary action to create the first one.
- Cleared: they finished everything. Acknowledge it lightly and point somewhere worth going.
- No results: say what was searched or filtered, and offer to clear it.

**Errors** answer three questions in plain words:

1. What happened? ("Your card was declined.")
2. Is my stuff safe? ("Nothing was charged." "Your note is still on your phone.")
3. What can I do now? One primary action, and an alternative.

Keep everything the person typed. Tell offline, server failure and missing permission apart,
because each needs a different action. Never show a raw error code on its own.

## 8. Hooks, with a line

The most addictive apps stack five mechanisms: variable rewards, no stopping cues, open loops,
social reinforcement and loss aversion (streaks). Together they form a loop: trigger, action,
unpredictable reward, investment.

The test for every engagement mechanic: **would the person thank you for it tomorrow?** If not,
don't build it, even if it moves a metric.

- Put stopping cues in: an end to the list, "You're all caught up", a summary that closes the day.
- Make streaks forgiving (a freeze, a weekly goal instead of a daily one). In sensitive areas like
  health, money, relationships or wellbeing, use no streaks or scores at all: keep a record, not a
  rating.
- Use surprise for discovery (something new and useful), never as a slot machine.
- Notify only about the person's own loops: a reply from someone they care about, a reminder they
  set, a deadline that matters to them. Never "We miss you", guilt or fake urgency.
- Never ship dark patterns: confirmshaming ("No thanks, I like paying more"), fake scarcity or
  countdowns, hidden cancellation, threats about losing a streak, or an endless feed in an app meant
  for focus or wellbeing.

## Checklist

Run this before calling a screen or flow done.

- [ ] Data the app already has is prefilled; the likely option is preselected.
- [ ] One recommendation comes first; long lists are grouped, filtered or searchable.
- [ ] One loud thing per screen; only tokens, no one-off radii, sizes or colours.
- [ ] Motion matches how often the moment happens; nothing blocks input; Reduce Motion respected.
- [ ] The peak and the end are designed; the worst moment is softened.
- [ ] Delight answers a deliberate action and plays once.
- [ ] Waits never flash, show real steps, are never padded, and never hit 100% early.
- [ ] Progress shows the distance left and counts real completed steps.
- [ ] Every empty state has a next step; every error says what happened, that data is safe, and what to do.
- [ ] Every hook passes "would they thank you for it tomorrow?"

## When reviewing an existing app

Report findings as a table: rule, what you found, `file:line`, the fix. Fix in this order, because
it is roughly the order people feel them: dead ends and errors, then waits, then anticipation, then
consistency, then motion, then delight.