home / skills / first-fluke / fullstack-starter / mobile-agent

mobile-agent skill

safe

This skill helps you build cross-platform mobile apps with Flutter and React Native, enforcing clean architecture, offline-first design, and platform-specific

npx playbooks add skill first-fluke/fullstack-starter --skill mobile-agent

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

Files (8)

SKILL.md

1.6 KB

---
name: mobile-agent
description: Mobile specialist for Flutter, React Native, and cross-platform mobile development
---

# Mobile Agent - Cross-Platform Mobile Specialist

## When to use
- Building native mobile applications (iOS + Android)
- Mobile-specific UI patterns
- Platform features (camera, GPS, push notifications)
- Offline-first architecture

## When NOT to use
- Web frontend -> use Frontend Agent
- Backend APIs -> use Backend Agent

## Core Rules
1. Clean Architecture: domain -> data -> presentation
2. Riverpod/Bloc for state management (no raw setState for complex logic)
3. Material Design 3 (Android) + iOS HIG (iOS)
4. All controllers disposed in `dispose()` method
5. Dio with interceptors for API calls; handle offline gracefully
6. 60fps target; test on both platforms

## How to Execute
Follow `resources/execution-protocol.md` step by step.
See `resources/examples.md` for input/output examples.
Before submitting, run `resources/checklist.md`.

## Serena Memory (CLI Mode)
See `../_shared/memory-protocol.md`.

## References
- Execution steps: `resources/execution-protocol.md`
- Code examples: `resources/examples.md`
- Code snippets: `resources/snippets.md`
- Checklist: `resources/checklist.md`
- Error recovery: `resources/error-playbook.md`
- Tech stack: `resources/tech-stack.md`
- Screen template: `resources/screen-template.dart`
- Context loading: `../_shared/context-loading.md`
- Reasoning templates: `../_shared/reasoning-templates.md`
- Clarification: `../_shared/clarification-protocol.md`
- Context budget: `../_shared/context-budget.md`
- Lessons learned: `../_shared/lessons-learned.md`

Overview

This skill is a mobile specialist focused on Flutter, React Native, and cross-platform mobile development. It guides teams through production-ready patterns, platform-specific UI, offline-first behavior, and performance targets. It pairs architectural rules with practical execution steps and checklists to ship reliable iOS and Android apps.

How this skill works

The skill inspects app architecture, state management choices, networking, lifecycle handling, and performance hotspots. It validates patterns against Clean Architecture, enforces disposal and lifecycle rules, and recommends concrete libraries and interceptors for networking. It also provides step-by-step execution guidance, example screens, and a pre-submit checklist to reduce regressions.

When to use it

Building native-feeling iOS and Android apps with a shared codebase.
Designing mobile-specific UI patterns and platform adaptations.
Integrating device features: camera, GPS, sensors, and push notifications.
Implementing offline-first behavior and robust sync strategies.
Optimizing app performance for smooth 60fps experiences.

Best practices

Adopt Clean Architecture: separate domain, data, and presentation layers.
Use Riverpod or Bloc for state management; avoid raw setState for complex logic.
Follow Material Design 3 on Android and iOS Human Interface Guidelines on iOS.
Dispose controllers and streams in appropriate lifecycle methods.
Use Dio (or equivalent) with interceptors for API calls and graceful offline handling.
Test on both platforms and target 60fps; include perf checks in the checklist.

Example use cases

Create a cross-platform auth flow with secure token refresh and offline queuing.
Implement a map-based feature with GPS, caching, and background location handling.
Build a camera capture and upload flow with retries and network-aware behavior.
Design a settings/profile area that follows each platform’s native conventions.
Add push notifications with platform-specific presentation and deep links.

FAQ

Which state management should I pick for complex logic?

Prefer Riverpod or Bloc for predictable, testable state. Use lighter approaches only for trivial, local UI state.

How do I handle offline and sync?

Queue mutations locally, use network-aware interceptors, and reconcile on reconnect. Include conflict resolution in the domain layer.