Prompts for mobile app design - onboarding, navigation, native patterns, notifications, gestures, offline. Use them when building or auditing iOS / Android apps.
First-launch experience.
Design first-launch onboarding for [APP]. Time-to-value target: [PASTE]. Permissions needed: [PASTE]. Output: 1) the 3-5 screen sequence, 2) the permission-prompt strategy (timing and framing), 3) the account-creation timing, 4) the magic moment screen, 5) the skip rule. End with the metric I'd track in day 1.
Pick the right primary navigation.
Help me decide primary nav for [APP]. Top-level sections: [PASTE]. Frequency of use: [PASTE]. Output: 1) the recommendation with reasoning, 2) the trade-offs of alternatives, 3) the platform conventions to respect (iOS / Android), 4) the future-proofing if I add a section in 6 months, 5) the test that would prove it wrong. End with the 1 nav pattern I should not use.
Gestures that don't surprise users.
Design the gesture system for [APP]. Core actions: [PASTE]. Output: 1) the swipe / pinch / long-press / pull mappings, 2) the discoverability for each, 3) the platform-convention conflicts to avoid, 4) the haptic feedback pairing, 5) the fallback for accessibility. End with the gesture that's tempting but lands as confusing.
Send fewer, land harder.
Design a notification strategy for [APP]. User intent signals: [PASTE]. Output: 1) the categories (transactional, engagement, marketing, lifecycle), 2) the frequency caps, 3) the timing rules, 4) the copy patterns per category, 5) the opt-in / opt-out granularity. End with the notification I should never send.
Empty without feeling empty.
Design the empty state for [SCREEN] in [APP]. User state: [PASTE]. Output: 1) the headline (under 5 words), 2) the supporting line, 3) the primary CTA, 4) the secondary helpful link, 5) the illustration concept. End with the variant for second-time users who just cleared their list.
What works without a connection.
Design the offline experience for [APP]. Critical paths: [PASTE]. Output: 1) the screens that must work offline, 2) the data sync model (read-only cache, write-through, optimistic), 3) the offline UI affordance, 4) the conflict-resolution UI, 5) the reconnect feedback. End with the failure mode users will hit first.
Get yes without dark patterns.
Design the permission request for [PERMISSION]. Why we need it: [PASTE]. Trade-off if denied: [PASTE]. Output: 1) the pre-prompt screen (explanation before the OS dialog), 2) the timing trigger, 3) the copy that earns the yes, 4) the recovery if denied, 5) the settings deep-link. End with the framing I'd refuse to use.
Forms that don't hurt on a phone.
Design a form-heavy screen for [TASK] on mobile. Field list: [PASTE]. Output: 1) the field grouping and order, 2) the keyboard-type per field, 3) the auto-fill and tab order, 4) the inline validation pattern, 5) the submit confirmation. End with the 1 field that should never be a free-text input on mobile.
Settings users can navigate.
Design the settings screen for [APP]. Current settings: [PASTE]. Output: 1) the top-level groupings, 2) the order within each group, 3) the destructive-action placement and confirmation, 4) the searchable structure, 5) the rule for what's a setting vs preference. End with the 1 setting I should default differently and explain.
Icon that survives a crowded home screen.
Brief an app icon for [APP]. Brand: [PASTE]. Output: 1) the single concept the icon must communicate, 2) the visual references, 3) the visual anti-references, 4) the platform constraints (iOS rounded square, Android adaptive), 5) the small-size legibility test. End with the home-screen-context test.
Paywall that respects the user.
Design the in-app purchase / paywall flow for [APP]. Pricing: [PASTE]. Trigger moment: [PASTE]. Output: 1) the entry point and framing, 2) the value proposition copy, 3) the plan layout, 4) the social proof element, 5) the restore-purchase and decline paths. End with the dark pattern I'm tempted to use and shouldn't.
Same app, two platforms, smart split.
Decide where to converge and diverge for [APP] across iOS and Android. Output: 1) the brand-side conventions to keep identical, 2) the platform-side conventions to respect natively, 3) the patterns that should adapt (back navigation, share, swipe), 4) the design-debt areas if I converge wrong, 5) the design-system token strategy. End with the rule for new patterns.
Loading that doesn't feel like waiting.
Design the loading states for [APP]. Common load durations: [PASTE]. Output: 1) the skeleton vs spinner rule by duration, 2) the optimistic UI candidates, 3) the long-load patience-building messaging, 4) the failure-after-load handling, 5) the perceived-performance tricks. End with the 1 spinner-driven screen I should rebuild with skeletons.
Feedback users feel and hear.
Design haptic and audio feedback for [APP]. Key actions: [PASTE]. Output: 1) the haptic event for each action (light, medium, heavy, success, warning, error), 2) the audio cue and when it's worth the battery, 3) the accessibility implications, 4) the user setting to disable, 5) the platform-native pattern to lean on. End with the 1 action that should NOT have any feedback.
Widget worth installing.
Design home-screen widgets for [APP]. Content available: [PASTE]. Output: 1) the small / medium / large widget content, 2) the refresh cadence, 3) the deep-link behavior on tap, 4) the personalization options, 5) the platform-specific constraints. End with the widget I should ship first.