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

2. Background sync

   • Queue write operations
   • Sync when connectivity available
   • Handle conflict resolution

3. 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

• references/cross-platform-comparison.md — React Native vs Flutter vs KMP vs native: performance, ecosystem, CI/CD, migration paths

• references/mobile-testing-patterns.md — Testing pyramid, XCTest, Espresso, Detox, Maestro, device farms, performance testing

• references/offline-first-architecture.md — Local databases, sync strategies, conflict resolution, background sync, optimistic updates

• references/push-notifications-guide.md — APNs, FCM, permission patterns, notification channels, rich notifications, analytics

• references/deep-linking-guide.md — Universal Links, App Links, deferred deep links, React Native integration, routing architecture

• 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

Fact-Checking

• Use web search/web fetch to verify current external facts, versions, pricing, deadlines, regulations, or platform behavior before final answers.

• Prefer primary sources; report source links and dates for volatile information.

• If web access is unavailable, state the limitation and mark guidance as unverified.