mobile-design
sickn33/antigravity-awesome-skills
Touch-first design system preventing desktop thinking in mobile apps.
What is mobile-design?
A mobile-design philosophy and risk assessment framework for building touch-first, platform-respectful applications. Use this when designing or implementing any mobile feature to avoid common performance, UX, and security pitfalls.
- Assess mobile feasibility via MFRI (Mobile Feasibility & Risk Index) scoring before implementation
- Enforce mandatory platform clarity (iOS/Android/both), framework, and offline requirements upfront
- Identify and ban AI anti-patterns: ScrollView for lists, inline renders, gesture-only actions, hardcoded secrets
- Provide platform-specific defaults (touch targets, fonts, navigation patterns) for iOS and Android
- Guide performance optimization: memoization, FlatList patterns, native-driver animations, battery consciousness
- Establish UX psychology rules based on Fitts' Law and thumb-zone accessibility
How to install mobile-design
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill mobile-design- Explicit definition of target platform(s): iOS, Android, or both
- Chosen framework: React Native, Flutter, or native
- Understanding of your app's offline requirements and network constraints
How to use mobile-design
- 1.Read mandatory reference files first (mobile-design-thinking.md, touch-psychology.md, mobile-performance.md, platform-specific docs)
- 2.Before any design or code, ask clarifying questions: platform, framework, navigation, offline needs, device types, audience
- 3.Calculate MFRI score for the feature using the five dimensions (Platform Clarity, Interaction Complexity, Performance Risk, Offline Dependence, Accessibility Risk)
- 4.Review the anti-patterns table and confirm your approach avoids performance sins, touch/UX sins, and security sins
- 5.Complete the Mobile Checkpoint: document platform, framework, files read, three principles to apply, and anti-patterns to avoid
- 6.Implement using provided patterns (e.g., React.memo + useCallback + FlatList for lists, const widgets in Flutter)
Use cases
- Evaluating whether a complex gesture or animation is feasible before design handoff
- Preventing performance regressions when adding lists or heavy state to React Native apps
- Ensuring cross-platform consistency while respecting iOS and Android interaction norms
- Validating offline capability and sync strategy before backend integration
- Catching security issues like token storage in AsyncStorage or hardcoded API keys early
- Mobile app developers (React Native, Flutter, native iOS/Android)
- AI coding agents designing or implementing mobile screens
- Product managers reviewing mobile feature feasibility
- Teams building cross-platform applications
mobile-design FAQ
MFRI (Mobile Feasibility & Risk Index) is a scoring system (-10 to +10) that combines Platform Clarity and Accessibility Readiness, minus Interaction Complexity, Performance Risk, and Offline Dependence. Scores 6–10 are safe to proceed; 3–5 require validation; 0–2 are risky and need simplification; below 0 requires redesign.
No. The skill explicitly states: 'If you haven't read the platform file, you are not allowed to design UI.' Platform-specific files cover iOS and Android interaction norms, gestures, and typography that are non-negotiable for respectful design.
Unify business logic, data models, APIs, and validation. Diverge on navigation behavior, gestures, icons, and typography to respect each platform's conventions and user expectations.
ScrollView renders all items in memory at once, causing memory explosion and jank on mobile devices. Use FlatList (React Native) or ListView.builder (Flutter) instead, which virtualize rendering.
Redesign before implementation. A negative score means the feature is too complex, risky, or dependent on constraints that mobile cannot support. Simplify interactions or rethink the architecture.
Full instructions (SKILL.md)
Source of truth, from sickn33/antigravity-awesome-skills.
name: mobile-design description: "(Mobile-First · Touch-First · Platform-Respectful)" risk: unknown source: community date_added: "2026-02-27"
Mobile Design System
(Mobile-First · Touch-First · Platform-Respectful)
Philosophy: Touch-first. Battery-conscious. Platform-respectful. Offline-capable. Core Law: Mobile is NOT a small desktop. Operating Rule: Think constraints first, aesthetics second.
This skill exists to prevent desktop-thinking, AI-defaults, and unsafe assumptions when designing or building mobile applications.
1. Mobile Feasibility & Risk Index (MFRI)
Before designing or implementing any mobile feature or screen, assess feasibility.
MFRI Dimensions (1–5)
| Dimension | Question |
|---|---|
| Platform Clarity | Is the target platform (iOS / Android / both) explicitly defined? |
| Interaction Complexity | How complex are gestures, flows, or navigation? |
| Performance Risk | Does this involve lists, animations, heavy state, or media? |
| Offline Dependence | Does the feature break or degrade without network? |
| Accessibility Risk | Does this impact motor, visual, or cognitive accessibility? |
Score Formula
MFRI = (Platform Clarity + Accessibility Readiness)
− (Interaction Complexity + Performance Risk + Offline Dependence)
Range: -10 → +10
Interpretation
| MFRI | Meaning | Required Action |
|---|---|---|
| 6–10 | Safe | Proceed normally |
| 3–5 | Moderate | Add performance + UX validation |
| 0–2 | Risky | Simplify interactions or architecture |
| < 0 | Dangerous | Redesign before implementation |
2. Mandatory Thinking Before Any Work
⛔ STOP: Ask Before Assuming (Required)
If any of the following are not explicitly stated, you MUST ask before proceeding:
| Aspect | Question | Why |
|---|---|---|
| Platform | iOS, Android, or both? | Affects navigation, gestures, typography |
| Framework | React Native, Flutter, or native? | Determines performance and patterns |
| Navigation | Tabs, stack, drawer? | Core UX architecture |
| Offline | Must it work offline? | Data & sync strategy |
| Devices | Phone only or tablet too? | Layout & density rules |
| Audience | Consumer, enterprise, accessibility needs? | Touch & readability |
🚫 Never default to your favorite stack or pattern.
3. Mandatory Reference Reading (Enforced)
Universal (Always Read First)
| File | Purpose | Status |
|---|---|---|
| mobile-design-thinking.md | Anti-memorization, context-forcing | 🔴 REQUIRED FIRST |
| touch-psychology.md | Fitts’ Law, thumb zones, gestures | 🔴 REQUIRED |
| mobile-performance.md | 60fps, memory, battery | 🔴 REQUIRED |
| mobile-backend.md | Offline sync, push, APIs | 🔴 REQUIRED |
| mobile-testing.md | Device & E2E testing | 🔴 REQUIRED |
| mobile-debugging.md | Native vs JS debugging | 🔴 REQUIRED |
Platform-Specific (Conditional)
| Platform | File |
|---|---|
| iOS | platform-ios.md |
| Android | platform-android.md |
| Cross-platform | BOTH above |
❌ If you haven’t read the platform file, you are not allowed to design UI.
4. AI Mobile Anti-Patterns (Hard Bans)
🚫 Performance Sins (Non-Negotiable)
| ❌ Never | Why | ✅ Always |
|---|---|---|
| ScrollView for long lists | Memory explosion | FlatList / FlashList / ListView.builder |
| Inline renderItem | Re-renders all rows | useCallback + memo |
| Index as key | Reorder bugs | Stable ID |
| JS-thread animations | Jank | Native driver / GPU |
| console.log in prod | JS thread block | Strip logs |
| No memoization | Battery + perf drain | React.memo / const widgets |
🚫 Touch & UX Sins
| ❌ Never | Why | ✅ Always |
|---|---|---|
| Touch <44–48px | Miss taps | Min touch target |
| Gesture-only action | Excludes users | Button fallback |
| No loading state | Feels broken | Explicit feedback |
| No error recovery | Dead end | Retry + message |
| Ignore platform norms | Muscle memory broken | iOS ≠ Android |
🚫 Security Sins
| ❌ Never | Why | ✅ Always |
|---|---|---|
| Tokens in AsyncStorage | Easily stolen | SecureStore / Keychain |
| Hardcoded secrets | Reverse engineered | Env + secure storage |
| No SSL pinning | MITM risk | Cert pinning |
| Log sensitive data | PII leakage | Never log secrets |
5. Platform Unification vs Divergence Matrix
UNIFY DIVERGE
────────────────────────── ─────────────────────────
Business logic Navigation behavior
Data models Gestures
API contracts Icons
Validation Typography
Error semantics Pickers / dialogs
Platform Defaults
| Element | iOS | Android |
|---|---|---|
| Font | SF Pro | Roboto |
| Min touch | 44pt | 48dp |
| Back | Edge swipe | System back |
| Sheets | Bottom sheet | Dialog / sheet |
| Icons | SF Symbols | Material Icons |
6. Mobile UX Psychology (Non-Optional)
Fitts’ Law (Touch Reality)
- Finger ≠ cursor
- Accuracy is low
- Reach matters more than precision
Rules:
- Primary CTAs live in thumb zone
- Destructive actions pushed away
- No hover assumptions
7. Performance Doctrine
React Native (Required Pattern)
const Row = React.memo(({ item }) => (
<View><Text>{item.title}</Text></View>
));
const renderItem = useCallback(
({ item }) => <Row item={item} />,
[]
);
<FlatList
data={items}
renderItem={renderItem}
keyExtractor={(i) => i.id}
getItemLayout={(_, i) => ({
length: ITEM_HEIGHT,
offset: ITEM_HEIGHT * i,
index: i,
})}
/>
Flutter (Required Pattern)
class Item extends StatelessWidget {
const Item({super.key});
@override
Widget build(BuildContext context) {
return const Text('Static');
}
}
consteverywhere possible- Targeted rebuilds only
8. Mandatory Mobile Checkpoint
Before writing any code, you must complete this:
🧠 MOBILE CHECKPOINT
Platform: ___________
Framework: ___________
Files Read: ___________
3 Principles I Will Apply:
1.
2.
3.
Anti-Patterns I Will Avoid:
1.
2.
❌ Cannot complete → go back and read.
9. Framework Decision Tree (Canonical)
Need OTA + web team → React Native + Expo
High-perf UI → Flutter
iOS only → SwiftUI
Android only → Compose
No debate without justification.
10. Release Readiness Checklist
Before Shipping
- Touch targets ≥ 44–48px
- Offline handled
- Secure storage used
- Lists optimized
- Logs stripped
- Tested on low-end devices
- Accessibility labels present
- MFRI ≥ 3
11. Related Skills
- frontend-design – Visual systems & components
- frontend-dev-guidelines – RN/TS architecture
- backend-dev-guidelines – Mobile-safe APIs
- error-tracking – Crash & performance telemetry
Final Law: Mobile users are distracted, interrupted, and impatient—often using one hand on a bad network with low battery. Design for that reality, or your app will fail quietly.
When to Use
This skill is applicable to execute the workflow or actions described in the overview.
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
Related skills
More from sickn33/antigravity-awesome-skills and the wider catalog.

mobile-developer
Develop React Native, Flutter, or native mobile apps with modern architecture patterns. Masters cross-platform development, native integrations, offline sync, and app store optimization.

multi-agent-brainstorming
Simulate a structured peer-review process using multiple specialized agents to validate designs, surface hidden assumptions, and identify failure modes before implementation.

nanobanana-ppt-skills
AI-powered PPT generation with document analysis and styled images

neon-postgres
Expert patterns for Neon serverless Postgres, branching, connection

nestjs-expert
Expert guidance for enterprise Nest.js architecture, dependency injection, testing, and authentication.

nextjs-best-practices
Master Next.js App Router: Server Components, data fetching, routing patterns, and performance optimization.