Mobile Development Skill — Quick Reference
This skill equips mobile developers with execution-ready patterns for building native and cross-platform mobile applications. Apply these patterns when you need iOS/Android app architecture, UI components, navigation flows, API integration, offline storage, authentication, or mobile-specific features.
When to Use This Skill
Use this skill when you need:
iOS app development (Swift, SwiftUI, UIKit) Android app development (Kotlin, Jetpack Compose) Cross-platform development (React Native, WebView) Mobile app architecture and patterns Navigation and routing State management (Redux, MobX, MVVM) Network requests and API integration Local data storage (Core Data, Room, SQLite) Authentication and session management Push notifications (APNs, FCM) Camera and media access Location services App Store / Play Store deployment Mobile performance optimization Offline-first architecture Deep linking and universal links Quick Reference Table Task iOS Android Cross-Platform When to Use Native UI SwiftUI + UIKit Jetpack Compose + Views React Native Native: Best performance; Cross-platform: Code sharing Navigation NavigationStack Navigation Component React Navigation Platform-specific for native feel State Management @State/@Observable ViewModel + StateFlow Redux/MobX iOS: @Observable; Android: ViewModel; RN: Redux Networking URLSession + async/await Retrofit + Coroutines Axios/Fetch Native: Type-safe; RN: JavaScript ecosystem Local Storage Core Data + SwiftData Room Database AsyncStorage/SQLite Native: Full control; RN: Simpler Push Notifications APNs FCM React Native Firebase Native: Platform-specific; RN: Unified API Background Tasks BGTaskScheduler WorkManager Headless JS For scheduled/background work Deep Linking Universal Links App Links React Navigation linking For URL-based app entry Authentication AuthenticationServices Credential Manager Expo AuthSession For social/biometric auth Analytics Firebase/Amplitude Firebase/Amplitude Expo Analytics Track user behavior Decision Tree: Platform Selection Need to build mobile app for: [Target Audience] │ ├─ iOS only? │ ├─ New app? → SwiftUI (modern, declarative) │ ├─ Existing UIKit codebase? → UIKit + incremental SwiftUI adoption │ └─ Complex animations? → UIKit for fine-grained control │ ├─ Android only? │ ├─ New app? → Jetpack Compose (modern, declarative) │ ├─ Existing Views codebase? → Views + incremental Compose adoption │ └─ Complex custom views? → Custom View for fine-grained control │ ├─ Both iOS and Android? │ ├─ Need maximum performance / platform fidelity? │ │ └─ Build separate native apps (Swift + Kotlin) │ │ │ ├─ Need faster development + code sharing? │ │ ├─ JavaScript/TypeScript team? → React Native (Expo-managed or bare) │ │ ├─ Dart team? → Flutter │ │ └─ Kotlin team? → Kotlin Multiplatform (KMP) │ │ │ ├─ Kotlin Multiplatform (KMP)? │ │ ├─ Share business logic only? → KMP shared module + native UI │ │ ├─ Share some UI? → Compose Multiplatform (validate iOS maturity for your needs) │ │ └─ Shared modules need platform UI? → Keep native UI, share domain/data/networking │ │ │ └─ Wrapping existing web app? │ ├─ Simple wrapper? → WebView (iOS WKWebView / Android WebView) │ └─ Native features needed? → Capacitor or React Native WebView │ └─ Prototype/MVP only? └─ React Native or Flutter for fastest iteration
Decision Tree: Architecture Pattern Choosing architecture pattern? │ ├─ iOS (Swift)? │ ├─ SwiftUI app? → MVVM with @Observable/ObservableObject (based on OS baseline) │ ├─ Complex SwiftUI? → TCA (Composable Architecture) for testability │ ├─ UIKit app? → MVVM-C (Coordinator pattern) │ ├─ Large team? → Clean Architecture + MVVM │ └─ Simple app? → MVC (Apple default) │ ├─ Android (Kotlin)? │ ├─ Compose app? → MVVM with ViewModel + StateFlow │ ├─ Views app? → MVVM with LiveData │ ├─ Large team? → Clean Architecture + MVVM │ └─ Simple app? → Activity/Fragment-based │ └─ React Native? ├─ Small app? → Context API + useState ├─ Medium app? → Redux Toolkit or Zustand └─ Large app? → Redux + RTK Query + feature-based structure
Decision Tree: Data Persistence Need to store data locally? │ ├─ Simple key-value pairs? │ ├─ iOS → UserDefaults │ ├─ Android → SharedPreferences / DataStore │ └─ RN → AsyncStorage │ ├─ Structured data with relationships? │ ├─ iOS → Core Data or SwiftData │ ├─ Android → Room Database │ └─ RN → WatermelonDB or Realm │ ├─ Secure credentials? │ ├─ iOS → Keychain │ ├─ Android → EncryptedSharedPreferences / Keystore │ └─ RN → react-native-keychain │ └─ Large files/media? ├─ iOS → FileManager (Documents/Cache) ├─ Android → Internal/External Storage └─ RN → react-native-fs
Decision Tree: Networking Need to make API calls? │ ├─ iOS? │ ├─ Simple REST? → URLSession + async/await │ ├─ Complex API? → URLSession + Codable │ └─ GraphQL? → Apollo iOS │ ├─ Android? │ ├─ Simple REST? → Retrofit + Coroutines │ ├─ Complex API? → Retrofit + OkHttp interceptors │ └─ GraphQL? → Apollo Android │ └─ React Native? ├─ Simple REST? → fetch() or Axios ├─ Complex API? → RTK Query or React Query └─ GraphQL? → Apollo Client
Core Capabilities iOS Development UI Frameworks: SwiftUI (declarative), UIKit (imperative) Architecture: MVVM, Clean Architecture, Coordinator, TCA (Composable Architecture) Concurrency: Swift Concurrency (async/await, actors, TaskGroup); keep UI state on @MainActor; enable strict concurrency checks as appropriate Storage: Core Data, SwiftData, Keychain Networking: URLSession, async/await patterns Platform compliance: Privacy manifests + required-reason APIs, background execution limits, and accessibility settings (Dynamic Type, VoiceOver) Defensive Decoding: Handle missing fields, array/dict formats, snake_case/camelCase Android Development UI Frameworks: Jetpack Compose (declarative), Views (XML) Architecture: MVVM, Clean Architecture, MVI Concurrency: Coroutines, Flow, LiveData Storage: Room, DataStore, Keystore Networking: Retrofit, OkHttp, Ktor Cross-Platform Development Kotlin Multiplatform (KMP): Share domain/data/networking; keep native UI; consider Compose Multiplatform when shared UI is worth the constraints React Native: JavaScript/TypeScript; evaluate New Architecture readiness and native-module surface area; Expo-managed path is often fastest for greenfield apps Flutter: Dart; high code sharing; validate platform-specific gaps and plugin maturity for your requirements WebView: WKWebView (iOS), WebView (Android), JavaScript bridge Platform Baselines (Verify Current Requirements) iOS/iPadOS (Core) Privacy manifest files (app + embedded SDKs) are maintained and reviewed https://developer.apple.com/documentation/bundlereferences/privacy_manifest_files Required-reason APIs are declared with valid reasons https://developer.apple.com/documentation/bundlereferences/privacy_manifest_files Background work uses supported primitives (avoid fragile timers) https://developer.apple.com/documentation/backgroundtasks App Transport Security is configured; exceptions are justified and documented https://developer.apple.com/documentation/bundlereferences/information_property_list/nsapptransportsecurity Concurrency is implemented with Swift Concurrency (async/await, actors, TaskGroup) and checked with current Swift language mode settings https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html Swift 6 migration / strict concurrency guidance is followed when upgrading toolchains https://developer.apple.com/documentation/swift/adoptingswift6 UI/UX follows current Human Interface Guidelines (including accessibility) https://developer.apple.com/design/human-interface-guidelines/ios Android (Core) Background work uses WorkManager for deferrable, guaranteed work https://developer.android.com/topic/libraries/architecture/workmanager Network calls and auth state survive process death (no hidden singleton assumptions) [Inference] Target SDK meets current Google Play requirements (verify policy + deadlines) https://support.google.com/googleplay/android-developer/answer/11926878 Prefer Play Integrity API over deprecated SafetyNet Attestation https://developer.android.com/google/play/integrity Prefer Credential Manager for passkeys and modern sign-in flows https://developer.android.com/identity/sign-in/credential-manager Cross-Platform (Core) Feature parity is explicit (document what is native-only vs shared) [Inference] Bridges are treated as public APIs (versioned, tested, and observable) [Inference] React Native upgrades follow the official upgrade guide; validate New Architecture readiness against your native-module surface area https://reactnative.dev/docs/upgrading Expo SDK upgrades follow Expo release notes and upgrade guides https://expo.dev/changelog Optional: AI/Automation Extensions
Note: Skip unless the app ships AI/automation features.
iOS: Core ML / on-device inference primitives https://developer.apple.com/documentation/coreml Android: Google ML Kit https://developers.google.com/ml-kit Verify: model size/battery impact, offline/online behavior, user controls (cancel/undo), and privacy boundaries [Inference] Common Patterns App Startup Checklist
Initialize dependencies
Configure DI container (Hilt/Koin/Swinject) Set up logging and crash reporting Initialize analytics
Check authentication state
Validate stored tokens Refresh if needed Route to login or main screen
Configure app state
Load user preferences Set up push notification handlers Initialize deep link handling Offline-First Architecture 1. Local-first data access - Always read from local database - Display cached data immediately - Show loading indicator for sync
- Background sync
- Queue write operations
- Sync when connectivity available
-
Handle conflict resolution
-
Optimistic updates
- Update UI immediately
- Sync in background
- Rollback on failure
Push Notification Setup iOS (APNs): 1. Enable Push Notifications capability 2. Request user permission 3. Register for remote notifications 4. Handle device token 5. Implement notification delegate
Android (FCM): 1. Add Firebase to project 2. Implement FirebaseMessagingService 3. Handle notification/data messages 4. Manage notification channels (Android 8+) 5. Handle background/foreground states
Performance Optimization Area iOS Android Metric Launch time Pre-warm, lazy loading Cold start optimization < 2s cold start List scrolling LazyVStack, prefetch LazyColumn, paging 60 FPS Image loading AsyncImage, cache Coil/Glide, disk cache < 100ms visible Memory Instruments profiling LeakCanary, Profiler No memory leaks Battery Background App Refresh limits Doze mode compliance Minimal drain App Store Deployment Checklist iOS App Store App icons (all required sizes) Launch screen configured Privacy manifest per target and embedded frameworks (iOS 18+) Required-reason APIs declared with justifications Third-party SDK privacy manifests attached; SDK signature attestation (iOS 19+) Info.plist permissions explanations App Store screenshots (all device sizes) App Store description and keywords Privacy policy URL TestFlight beta testing Google Play Store App icons and feature graphic Store listing screenshots Privacy policy URL Content rating questionnaire Target API level compliance Data safety form Internal/closed/open testing tracks Navigation Resources references/ios-best-practices.md — iOS architecture, concurrency, testing, performance, defensive decoding, and accessibility references/android-best-practices.md — Android/Kotlin architecture, coroutines, Compose, testing, performance references/operational-playbook.md — Mobile architecture patterns, platform-specific guides, security notes, and decision tables README.md — Folder overview and usage notes data/sources.json — Curated external references by platform Shared Checklists ../software-clean-code-standard/assets/checklists/mobile-release-checklist.md — Product-agnostic mobile release readiness checklist (core + optional AI) Shared Utilities (Centralized patterns — extract, don't duplicate) ../software-clean-code-standard/utilities/auth-utilities.md — Argon2id, jose JWT, OAuth 2.1/PKCE (backend auth for mobile clients) ../software-clean-code-standard/utilities/error-handling.md — Error patterns, Result types ../software-clean-code-standard/utilities/resilience-utilities.md — Retry, circuit breaker for network calls ../software-clean-code-standard/utilities/logging-utilities.md — Structured logging patterns ../software-clean-code-standard/utilities/testing-utilities.md — Test factories, fixtures, mocks ../software-clean-code-standard/references/clean-code-standard.md — Canonical clean code rules (CC-*) for citation Templates Swift: assets/swift/template-swift.md, assets/swift/template-swift-concurrency.md, assets/swift/template-swift-combine.md, assets/swift/template-swift-performance.md, assets/swift/template-swift-testing.md SwiftUI: assets/swiftui/template-swiftui-advanced.md Kotlin/Android: assets/kotlin/template-kotlin.md, assets/kotlin/template-kotlin-coroutines.md, assets/kotlin/template-kotlin-compose-advanced.md, assets/kotlin/template-kotlin-testing.md Cross-platform: assets/cross-platform/template-platform-patterns.md, assets/cross-platform/template-webview.md Anti-Patterns to Avoid Anti-Pattern Problem Solution Blocking main thread UI freezes, ANRs Use async/coroutines for all I/O Massive view controllers Hard to test/maintain Extract to MVVM/services Hardcoded strings No localization Use NSLocalizedString/strings.xml Ignoring lifecycle Memory leaks, crashes Respect activity/view lifecycle No offline handling Poor UX without network Cache data, queue operations Storing secrets in code Security vulnerability Use Keychain/Keystore Using decode() without fallback Crashes on missing/malformed API data Use decodeIfPresent() with defaults Missing @Bindable for @Observable NavigationStack bindings don't work Add @Bindable var vm = vm in body Trend Awareness Protocol
IMPORTANT: When users ask recommendation questions about mobile development, you MUST use a web search capability (if available) to check current trends before answering. If web search is unavailable, say so and answer using data/sources.json, clearly flagging that the recommendation may be stale.
Trigger Conditions "What's the best mobile framework for [use case]?" "What should I use for [cross-platform/native/hybrid]?" "What's the latest in iOS/Android development?" "Current best practices for [Swift/Kotlin/React Native]?" "Is [React Native/Flutter/Expo] still relevant in 2026?" "[React Native] vs [Flutter] vs [native]?" "Best approach for [offline/push/deep linking]?" Required Searches Search: "mobile development best practices 2026" Search: "[iOS/Android/React Native/Flutter] updates 2026" Search: "mobile framework comparison 2026" Search: "[Expo/Swift/Kotlin] new features 2026" What to Report
After searching, provide:
Current landscape: What frameworks/approaches are popular NOW Emerging trends: New patterns or tools gaining traction Deprecated/declining: Approaches that are losing relevance Recommendation: Based on fresh data and recent releases Example Topics (verify with fresh search) Current iOS + Swift Concurrency migration guidance Current Play target SDK policy and identity/auth guidance React Native New Architecture maturity and upgrade pain points Expo-managed vs bare React Native tradeoffs Flutter vs React Native vs KMP ecosystem in 2026 Compose Multiplatform readiness for iOS in 2026 Related Skills ../software-frontend/SKILL.md — Web-facing UI patterns and Next.js integration ../software-backend/SKILL.md — API design, auth, and backend contracts for mobile clients ../qa-testing-strategy/SKILL.md — Mobile CI, test strategy, and reliability gates ../qa-resilience/SKILL.md — Resilience patterns for networked mobile apps ../qa-testing-ios/SKILL.md — iOS-focused test planning, XCTest/Swift Testing patterns, device matrix, and app health checks ../software-ui-ux-design/SKILL.md — Mobile UI/UX design patterns and accessibility