home / skills / hyperb1iss / hyperskills / mobile

mobile skill

/skills/mobile

This skill helps you build native-quality mobile apps with React Native and Expo, guiding navigation, deep linking, native modules, and push notifications.

npx playbooks add skill hyperb1iss/hyperskills --skill mobile

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

Files (1)
SKILL.md
4.3 KB
---
name: mobile
description: Use this skill when building mobile applications, React Native apps, Expo projects, iOS/Android development, or cross-platform mobile features. Activates on mentions of React Native, Expo, mobile app, iOS, Android, Swift, Kotlin, Flutter, app store, push notifications, deep linking, mobile navigation, or native modules.
---

# Mobile Development

Build native-quality mobile apps with React Native and Expo.

## Quick Reference

### Expo SDK 53+ (2026 Standard)

**New Architecture is DEFAULT** - No opt-in required.

```bash
# Create new project
npx create-expo-app@latest my-app
cd my-app
npx expo start
```

**Key Changes:**

- Hermes engine default (JSC deprecated)
- Fabric renderer + Bridgeless mode
- All `expo-*` packages support New Architecture
- `expo-video` replaces `expo-av` for video
- `expo-audio` replaces `expo-av` for audio

### Project Structure

```
app/
├── (tabs)/           # Tab navigation group
│   ├── index.tsx     # Home tab
│   ├── profile.tsx   # Profile tab
│   └── _layout.tsx   # Tab layout
├── [id].tsx          # Dynamic route
├── _layout.tsx       # Root layout
└── +not-found.tsx    # 404 page
```

### Navigation (Expo Router)

```tsx
// app/_layout.tsx
import { Stack } from "expo-router";

export default function Layout() {
  return (
    <Stack>
      <Stack.Screen name="(tabs)" options={{ headerShown: false }} />
      <Stack.Screen name="modal" options={{ presentation: "modal" }} />
    </Stack>
  );
}
```

**Deep Linking**

```tsx
// Navigate programmatically
import { router } from "expo-router";
router.push("/profile/123");
router.replace("/home");
router.back();
```

### Native Modules (New Architecture)

**Turbo Modules** - Synchronous, type-safe native access:

```tsx
// specs/NativeCalculator.ts
import type { TurboModule } from "react-native";
import { TurboModuleRegistry } from "react-native";

export interface Spec extends TurboModule {
  multiply(a: number, b: number): number;
}

export default TurboModuleRegistry.getEnforcing<Spec>("Calculator");
```

### Styling

**NativeWind (Tailwind for RN)**

```tsx
import { View, Text } from "react-native";

export function Card() {
  return (
    <View className="bg-white rounded-xl p-4 shadow-lg">
      <Text className="text-lg font-bold text-gray-900">Title</Text>
    </View>
  );
}
```

### State Management

Same as web - TanStack Query for server state, Zustand for client:

```tsx
import { useQuery } from "@tanstack/react-query";

function ProfileScreen() {
  const { data: user } = useQuery({
    queryKey: ["user"],
    queryFn: fetchUser,
  });
  return <UserProfile user={user} />;
}
```

### OTA Updates

```tsx
// app.config.js
export default {
  expo: {
    updates: {
      url: "https://u.expo.dev/your-project-id",
      fallbackToCacheTimeout: 0,
    },
    runtimeVersion: {
      policy: "appVersion",
    },
  },
};
```

### Push Notifications

```tsx
import * as Notifications from "expo-notifications";

// Request permissions
const { status } = await Notifications.requestPermissionsAsync();

// Get push token
const token = await Notifications.getExpoPushTokenAsync({
  projectId: "your-project-id",
});

// Schedule local notification
await Notifications.scheduleNotificationAsync({
  content: { title: "Reminder", body: "Check the app!" },
  trigger: { seconds: 60 },
});
```

### Performance Tips

1. **Use FlashList** over FlatList for long lists
2. **Avoid inline styles** - Use StyleSheet.create or NativeWind
3. **Optimize images** - Use expo-image with caching
4. **Profile with Flipper** or React DevTools

### Build & Deploy

```bash
# Development build
npx expo run:ios
npx expo run:android

# Production build (EAS)
eas build --platform all --profile production

# Submit to stores
eas submit --platform ios
eas submit --platform android
```

## Agents

- **mobile-app-builder** - Full mobile development expertise

## Deep Dives

- [references/expo-sdk-53.md](references/expo-sdk-53.md)
- [references/new-architecture.md](references/new-architecture.md)
- [references/native-modules.md](references/native-modules.md)
- [references/app-store-submission.md](references/app-store-submission.md)

## Examples

- [examples/expo-starter/](examples/expo-starter/)
- [examples/push-notifications/](examples/push-notifications/)
- [examples/native-module/](examples/native-module/)

Overview

This skill helps you build native-quality mobile apps using React Native and Expo, covering project setup, navigation, native modules, push notifications, and performance best practices. It targets modern Expo SDKs (New Architecture default) and common cross-platform needs for iOS and Android developers. Use it to accelerate feature development, debugging, and app store deployment workflows.

How this skill works

The skill inspects project structure, recommends Expo Router navigation patterns, and shows examples for Turbo Modules, deep linking, and push notifications. It provides code snippets for setup, navigation, styling with NativeWind, state management, OTA updates, and build/deploy commands. It highlights performance optimizations and migration changes for recent Expo SDKs.

When to use it

  • Starting a new Expo or React Native project with modern architecture
  • Implementing deep linking, in-app navigation, or modal flows
  • Adding native functionality via Turbo Modules or bridging native code
  • Configuring push notifications and scheduling local notifications
  • Optimizing performance for lists, images, and render paths
  • Preparing builds and submissions for App Store and Play Store

Best practices

  • Use npx create-expo-app and follow the Expo Router project structure for predictable routing
  • Prefer Hermes and Fabric (New Architecture) defaults for consistent runtime behavior
  • Use NativeWind or StyleSheet.create to avoid inline styles and improve rendering
  • Choose FlashList for long lists and expo-image for optimized image caching
  • Centralize server state with TanStack Query and client state with Zustand
  • Configure OTA updates and runtimeVersion to support seamless user updates

Example use cases

  • Create a tabbed app with modal flows using Expo Router and Stack screens
  • Add a native Turbo Module to expose synchronous native functionality (e.g., calculator)
  • Implement push notifications: request permissions, obtain token, schedule notifications
  • Optimize a feed by swapping FlatList for FlashList and using expo-image caching
  • Build production artifacts with eas build and submit to stores using eas submit

FAQ

Do I need to opt in to the New Architecture in recent Expo SDKs?

No. New Architecture (Hermes, Fabric, Bridgeless) is the default in modern Expo SDKs; most expo-* packages support it.

How do I handle deep linking and programmatic navigation?

Use expo-router's router methods (router.push, router.replace, router.back) and organize routes under the app/ directory with dynamic segments for IDs.