home / skills / mosif16 / codex-skills / software-mobile

software-mobile skill

safe

This skill delivers production-grade mobile development guidance for iOS, Android, and cross-platform patterns covering architecture, UI, and deployment.

npx playbooks add skill mosif16/codex-skills --skill software-mobile

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

5.1 KB

---
name: software-mobile
description: Production-grade mobile app development with Swift (iOS), Kotlin (Android), React Native, and WebView patterns, including UI/UX, navigation, state management, networking, local storage, push notifications, and App Store deployment.
---

# Mobile Development Skill — Quick Reference

This skill equips mobile developers with execution-ready patterns for building native and cross-platform mobile applications. Claude should apply these patterns when users ask for iOS/Android app architecture, UI components, navigation flows, API integration, offline storage, authentication, or mobile-specific features.

---

# When to Use This Skill

Claude should invoke this skill when a user requests:

- 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
- Camera and media access
- Location services
- App Store / Play Store deployment
- Mobile performance optimization
- Offline-first architecture

---

## 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 |

## Decision Tree: Platform Selection

```text
Need to build mobile app for: [Target Audience]
    ├─ iOS only?
    │   └─ Use Swift + SwiftUI (templates/swift/)
    │
    ├─ Android only?
    │   └─ Use Kotlin + Jetpack Compose (templates/kotlin/)
    │
    ├─ Both iOS and Android?
    │   ├─ Need maximum performance?
    │   │   └─ Build separate native apps (Swift + Kotlin)
    │   │
    │   ├─ Need faster development + code sharing?
    │   │   └─ Use React Native (templates/cross-platform/)
    │   │
    │   └─ Wrapping existing web app?
    │       └─ Use WebView wrapper (templates/cross-platform/template-webview.md)
```

---

## Navigation

**Resources**
- [resources/ios-best-practices.md](resources/ios-best-practices.md) — iOS architecture, concurrency, testing, and performance
- [resources/android-best-practices.md](resources/android-best-practices.md) — Android/Kotlin architecture, coroutines, Compose, testing, performance
- [README.md](README.md) — Folder overview and usage notes
- [data/sources.json](data/sources.json) — Curated external references by platform

**Templates**
- Swift: [templates/swift/template-swift.md](templates/swift/template-swift.md), [templates/swift/template-swift-concurrency.md](templates/swift/template-swift-concurrency.md), [templates/swift/template-swift-combine.md](templates/swift/template-swift-combine.md), [templates/swift/template-swift-performance.md](templates/swift/template-swift-performance.md), [templates/swift/template-swift-testing.md](templates/swift/template-swift-testing.md)
- SwiftUI: [templates/swiftui/template-swiftui-advanced.md](templates/swiftui/template-swiftui-advanced.md)
- Kotlin/Android: [templates/kotlin/template-kotlin.md](templates/kotlin/template-kotlin.md), [templates/kotlin/template-kotlin-coroutines.md](templates/kotlin/template-kotlin-coroutines.md), [templates/kotlin/template-kotlin-compose-advanced.md](templates/kotlin/template-kotlin-compose-advanced.md), [templates/kotlin/template-kotlin-testing.md](templates/kotlin/template-kotlin-testing.md)
- Cross-platform: [templates/cross-platform/template-platform-patterns.md](templates/cross-platform/template-platform-patterns.md), [templates/cross-platform/template-webview.md](templates/cross-platform/template-webview.md)

**Related Skills**
- [../software-frontend/SKILL.md](../software-frontend/SKILL.md) — Web-facing UI patterns and Next.js integration
- [../software-backend/SKILL.md](../software-backend/SKILL.md) — API design, auth, and backend contracts for mobile clients
- [../software-testing-automation/SKILL.md](../software-testing-automation/SKILL.md) — Mobile CI, test strategy, and reliability gates
- [../quality-resilience-patterns/SKILL.md](../quality-resilience-patterns/SKILL.md) — Resilience patterns for networked mobile apps

---

## Operational Playbooks
- [resources/operational-playbook.md](resources/operational-playbook.md) — Mobile architecture patterns, platform-specific guides, security notes, and decision tables

Overview

This skill delivers production-grade mobile app patterns and templates for iOS (Swift, SwiftUI, UIKit), Android (Kotlin, Jetpack Compose), and cross-platform (React Native, WebView). It covers UI/UX, navigation, state management, networking, local storage, push notifications, and deployment workflows. Use it to choose platform strategy, follow best practices, and jumpstart implementation with tested patterns.

How this skill works

The skill provides concrete architecture guidance, code patterns, and template recommendations for common mobile scenarios. It maps tasks (UI, navigation, state, networking, storage, device features) to platform-specific solutions and cross-platform alternatives. It includes decision guidance for platform selection, integration patterns for offline and sync, and operational playbooks for release and performance.

When to use it

Starting a new mobile project and choosing native vs cross-platform
Designing app architecture, navigation, and state management
Integrating APIs, offline storage, and sync strategies
Implementing device features: push, camera, location, background tasks
Preparing builds and submission for App Store and Play Store
Optimizing mobile performance and reliability

Best practices

Prefer platform idioms: SwiftUI or UIKit for iOS, Compose for Android, React Native for shared logic
Use ViewModel + StateFlow (Android) or @State/@Observable (iOS) to centralize state and side effects
Adopt Retrofit/URLSession with async/await or coroutines for structured networking and retries
Design offline-first data flows with Room/Core Data and background sync jobs
Keep navigation consistent with platform navigation components for native feel
Automate CI/CD, code signing, and store submission checks to reduce release friction

Example use cases

Build an iOS-only consumer app with SwiftUI and Swift concurrency for smooth animations and low-latency networking
Create an Android app using Jetpack Compose, ViewModel, and Room with coroutine-based sync
Ship a cross-platform MVP with React Native, shared business logic, and native modules for camera and push
Wrap a web product in a WebView shell for quick mobile distribution while progressively adding native features
Implement secure authentication and session management with token storage and refresh flows

FAQ

Which platform should I pick for maximum performance?

Choose native: Swift for iOS and Kotlin for Android. Native apps provide the best platform integration and performance when resource use and UX fidelity are priorities.

When is React Native the right choice?

Use React Native when you need faster development and significant code sharing across platforms, especially for feature parity and teams familiar with JavaScript.