Advisor Mobile Champion

An agent that champions mobile development best practices, providing guidance on cross-platform strategies, native performance optimization, app store compliance, and mobile-specific UX patterns for building apps users love.

When to Use This Agent

Choose Mobile Champion when:

• Evaluating mobile development strategies (native vs cross-platform)
• Optimizing mobile app performance (startup time, memory, battery)
• Ensuring App Store and Play Store compliance for submission
• Implementing mobile-specific UX patterns (gestures, navigation, offline)
• Establishing mobile development standards for teams

Consider alternatives when:

• Building iOS-specific features with SwiftUI (use an iOS developer agent)
• Building Android-specific features with Kotlin (use an Android developer agent)
• Writing cross-platform code with a specific framework (use a framework-specific agent)

Quick Start

Copy
# .claude/agents/advisor-mobile-champion.yml
name: Mobile Champion
model: claude-sonnet-4-20250514
tools:
  - Read
  - Write
  - Bash
  - Glob
  - Grep
prompt: |
  You are a mobile development champion. Guide teams on mobile
  strategy, performance, UX, and app store compliance. Balance
  cross-platform efficiency with native quality. Advocate for
  mobile-first patterns that create apps users love to use.

Example invocation:

Copy
claude --agent advisor-mobile-champion "We're deciding between
  React Native, Flutter, and native development for a fintech
  app targeting iOS and Android. The app needs biometric auth,
  offline mode, and real-time transaction updates. Advise."

Core Concepts

Mobile Strategy Decision Matrix

Factor	Native	React Native	Flutter	PWA
Performance	Best	Good	Very Good	Adequate
Native API access	Full	Via bridges	Via plugins	Limited
Dev cost (2 platforms)	2x	1.3x	1.2x	1x
Time to market	Slowest	Medium	Medium	Fastest
UI fidelity	Best	Good (platform look)	Custom (consistent)	Basic
Offline support	Full	Good	Good	Limited
App Store required	Yes	Yes	Yes	No
Team skillset	Swift + Kotlin	JavaScript	Dart	Web

Mobile Performance Checklist

Startup:    Cold start < 2s, warm start < 1s
Rendering:  60fps for all animations and scrolling
Memory:     Stay under 200MB for typical usage
Battery:    No background drain, efficient location/networking
Network:    Graceful offline handling, request caching
Size:       App binary < 50MB (ideal), < 100MB (acceptable)

Mobile UX Patterns

Pattern	Use Case	Platform Considerations
Bottom Navigation	3-5 top-level sections	iOS TabBar, Android Bottom Nav
Pull to Refresh	Content lists	Standard on both platforms
Swipe Actions	List item operations	iOS standard, Android optional
Modal Sheets	Secondary flows	iOS sheets, Android bottom sheets
Haptic Feedback	Confirmations, errors	Platform APIs differ
Skeleton Loading	Content placeholder	Better than spinners

Configuration

Parameter	Description	Default
platforms	Target platforms	iOS + Android
strategy	Development approach	Evaluate per project
min_ios	Minimum iOS version	16.0
min_android	Minimum Android API	26 (Android 8)
performance_targets	Key performance metrics	Standard mobile
offline_strategy	Offline data approach	Cache-first
analytics	Mobile analytics platform	Firebase Analytics

Best Practices

1. Choose your mobile strategy based on your app's critical requirements, not the latest trends. If your app needs deep OS integration (AR, health sensors, complex animations), go native. If you need fast iteration with good-enough platform feel, React Native works well. If you want pixel-identical UI across platforms with great performance, Flutter delivers. PWAs work for simple content apps that don't need app store distribution. The wrong choice costs months of rework.

2. Optimize for perceived performance, not just measured performance. Users perceive an app that shows a skeleton screen after 200ms as faster than one that shows a spinner for 800ms, even though the total load time is the same. Use placeholder content, progressive loading, and optimistic updates to make the app feel instant. Prefetch data for screens the user is likely to navigate to next.

3. Design for offline-first, not just online-with-fallback. Mobile connections are unreliable. Build the app to work offline by default, syncing when connectivity is available. Cache API responses, queue write operations for later, and show clear indicators when the user is offline. An app that breaks when the phone enters a tunnel frustrates users; an app that works seamlessly earns loyalty.

4. Test on real devices, not just simulators. Simulators use your computer's fast CPU, abundant RAM, and reliable network. Real devices have thermal throttling, memory pressure, battery optimization, and spotty connections. Performance that looks fine in a simulator may be poor on a mid-range phone. Include at least one low-end device in your testing device set.

5. Follow each platform's design language for core navigation and interaction. Users expect iOS apps to use swipe-back navigation and bottom tabs. They expect Android apps to use material design and back button navigation. Cross-platform frameworks that impose one platform's conventions on another create cognitive friction. Adapt navigation patterns per platform, even when sharing business logic.

Common Issues

App gets rejected from the App Store or Play Store. Read rejection reasons carefully—they're usually specific and fixable. Common causes: requesting permissions without clear usage descriptions, using private APIs, displaying web content without proper disclosure, or linking to external payment for digital goods. Use TestFlight and Play Console's pre-launch reports to catch issues before submission.

App performance degrades on older or lower-end devices. Profile on your minimum supported device, not your latest flagship. Reduce animation complexity, limit concurrent network requests, implement efficient list rendering (recycling views), and paginate large datasets. Memory warnings on iOS and low-memory kills on Android are your signals that optimization is needed.

Cross-platform code works on one platform but breaks on the other. Test on both platforms throughout development, not just at the end. Platform-specific bugs often hide in: date/time handling, keyboard behavior, navigation transitions, permission request flows, and push notification handling. Run CI tests on both platform emulators and address platform-specific failures immediately.