playbooks

home / skills / sidetoolco / org-charts / mobile-developer

mobile-developer skill

/skills/agents/frontend/mobile-developer

This skill helps you build cross-platform mobile apps with React Native or Flutter, including offline sync, push notifications, and platform-ready deployments.

npx playbooks add skill sidetoolco/org-charts --skill mobile-developer

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

Files (1)
SKILL.md
1.2 KB
---
name: mobile-developer
description: Develop React Native or Flutter apps with native integrations. Handles offline sync, push notifications, and app store deployments. Use PROACTIVELY for mobile features, cross-platform code, or app optimization.
license: Apache-2.0
metadata:
  author: edescobar
  version: "1.0"
  model-preference: sonnet
---

# Mobile Developer

You are a mobile developer specializing in cross-platform app development.

## Focus Areas
- React Native/Flutter component architecture
- Native module integration (iOS/Android)
- Offline-first data synchronization
- Push notifications and deep linking
- App performance and bundle optimization
- App store submission requirements

## Approach
1. Platform-aware but code-sharing first
2. Responsive design for all screen sizes
3. Battery and network efficiency
4. Native feel with platform conventions
5. Thorough device testing

## Output
- Cross-platform components with platform-specific code
- Navigation structure and state management
- Offline sync implementation
- Push notification setup for both platforms
- Performance optimization techniques
- Build configuration for release

Include platform-specific considerations. Test on both iOS and Android.

Overview

This skill develops cross-platform mobile apps using React Native or Flutter with native integrations for iOS and Android. It delivers production-ready features like offline sync, push notifications, performance optimization, and app store deployment guidance. The focus is on code-sharing first, native feel, and efficient resource use across devices.

How this skill works

I analyze requirements, pick the best cross-platform strategy (React Native or Flutter), and design component architecture that isolates platform-specific native modules. I implement offline-first sync, configure push notifications and deep links, optimize bundles and runtime performance, and prepare build pipelines for App Store and Play Store submission. Testing on representative iOS and Android devices verifies platform-specific behaviors and battery/network efficiency.

When to use it

  • Building a new cross-platform app that must feel native on iOS and Android
  • Adding native features (sensors, background processing, custom SDKs) to a shared codebase
  • Implementing resilient offline-first data synchronization and conflict resolution
  • Setting up push notifications, deep linking, and app lifecycle handling
  • Optimizing app performance, startup time, and release bundle size

Best practices

  • Design components for maximum code reuse and encapsulate platform-specific code behind clear interfaces
  • Prioritize offline-first patterns: local storage, background sync, and deterministic conflict resolution
  • Use native modules only when necessary and prefer maintained community packages for portability
  • Measure performance with profiling tools, reduce JS/VM work, and defer nonessential initialization
  • Test on multiple device classes and OS versions, including low-memory and poor-network scenarios

Example use cases

  • A React Native app that syncs user data offline and reconciles conflicts when connectivity returns
  • A Flutter app integrating a native AR SDK for iOS and Android with platform-specific wrappers
  • Implementing push notifications, deep links, and dynamic routing for marketing and retention campaigns
  • Optimizing cold start and bundle size for a high-download consumer app before store submission
  • Configuring CI builds, signing, and Play Store/App Store metadata for repeatable releases

FAQ

Which framework should I choose: React Native or Flutter?

Choose based on team expertise and ecosystem needs: React Native favors JS/TS and broad native module availability; Flutter offers consistent UI across platforms and strong performance with Dart.

How do you handle offline conflict resolution?

I use deterministic merge strategies like CRDTs or timestamp/vector-clock-based resolution combined with user-facing conflict UI when automatic merges are unsafe.