Skip to main content
skill CX Codex

oma-mobile · first-fluke — Claude Code skill: what it does, how to install

oma-mobile is a skill that builds and edits mobile screens and features in Flutter, React Native, Swift, or Kotlin. It inspects existing widgets, providers, and API clients before code changes.

MIT ★ 1,472 updated 2026-11-05

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent
Open on GitHub

What oma-mobile does

The skill implements mobile features across domain, data, and presentation layers: it inspects current widgets or screens, providers or blocs, and API clients, then writes UI, state handling, platform integration, and offline logic. Interfaces follow Material Design 3 on Android and iOS HIG on iOS, with Riverpod or Bloc managing state instead of raw setState for anything non-trivial.

Network calls route through Dio on Flutter, axios behind TanStack Query on React Native, a generated Client on Swift, and Ktor plugins over *Api on Kotlin, each wired with auth, retry, and logging interceptors. On Swift targeting iOS 17+, the skill requires SwiftUI with @MainActor @Observable view models: mutating observed state from a Task in a non-isolated view model breaks Swift 6 strict concurrency.

Verification runs unit, widget, and integration tests, plus Maestro E2E for critical user flows. Controllers must dispose in dispose(), and the skill only falls back to its default stack when the project has no established architecture of its own.

What it helps with

  • structure a mobile screen with domain-data-presentation layering
  • wire up state through Riverpod or Bloc instead of setState
  • set up a network layer with auth and retry interceptors on Dio, axios, Swift Client, or Ktor
  • cover a critical user flow with Maestro E2E tests
  • add offline handling and native permissions for camera or GPS

Example prompts for the agent

  • Add a profile screen to the Flutter app with offline caching through Riverpod
  • Rewrite this view model for SwiftUI with @Observable and fix the strict-concurrency error
  • Cover the login flow with a Maestro E2E test

How to install oma-mobile

1Plugin marketplace

/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent

This installs the whole oma plugin with all its skills

2Skills CLI (Vercel)

npx skills add first-fluke/oh-my-agent --skill oma-mobile -a claude-code

3Manually: put the files in place

~/.claude/skills/oma-mobile/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/oma-mobile/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about oma-mobile

How do I install oma-mobile in Claude Code?

Run /plugin marketplace add first-fluke/oh-my-agent, then /plugin install oma@oh-my-agent.

What does the oma-mobile skill do?

It writes and edits mobile screens, widgets, and platform integrations across Flutter, React Native, Swift, and Kotlin, following layered architecture and running tests to verify the result.

What does oma-mobile require for Swift networking?

On iOS 17+ it expects SwiftUI view models marked @MainActor @Observable: mutating state from a Task in a non-isolated view model violates Swift 6 strict concurrency, and network calls go through a generated Client.

Source text

SKILL.md · MIT
---
name: oma-mobile
description: Implement Flutter, React Native, native Swift, or native Kotlin
  Android apps. Use for mobile screens, widgets, platform integrations, and
  application data flows.
---

# Mobile Agent - Cross-Platform Mobile Specialist

## Scheduling

### Goal
Build, modify, and verify cross-platform mobile application features with clean architecture, platform-appropriate UI, state management, performance, and E2E coverage.

### Intent signature
- User asks for mobile app, Flutter, Dart, React Native, iOS, Android, Jetpack Compose, Kotlin, Riverpod, widgets, camera, GPS, push notifications, or offline-first work.
- User needs native or cross-platform mobile behavior rather than web frontend work.

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

### Expected inputs
- Target screen, widget, feature, platform capability, or mobile flow
- Existing app architecture, state management pattern, API contract, and platform constraints
- Test expectations for unit, widget, integration, or Maestro E2E coverage

### Expected outputs
- Mobile code changes in domain, data, presentation, platform, or test files
- UI aligned with Material Design 3 and iOS HIG as applicable
- Verification results from mobile checks and critical-flow tests

### Dependencies
- Flutter/Dart, React Native, Swift, or Kotlin/Gradle toolchain as detected from the project
- Riverpod/Bloc, Dio, Hilt, Ktor, platform SDKs, and Maestro where applicable
- `resources/execution-protocol.md`, examples, snippets, checklist, and screen template

### Control-flow features
- Branches by platform, state management pattern, offline requirement, native permission, and test level
- Reads and writes mobile codebase files
- May call build, test, simulator, emulator, or E2E commands

## Structural Flow

### Entry
1. Identify target platform(s), screen/feature, architecture layer, and state boundary.
2. Inspect existing mobile patterns and dependencies.
3. Determine test level and verification environment.

### Scenes
1. **PREPARE**: Load app architecture, platform constraints, and acceptance criteria.
2. **ACQUIRE**: Read existing widgets/screens, providers/blocs, API clients, and tests.
3. **ACT**: Implement mobile UI, state, platform integration, offline handling, and tests.
4. **VERIFY**: Run relevant unit/widget/integration/E2E checks.
5. **FINALIZE**: Report behavior, platforms covered, and verification results.

### Transitions
- If business logic is complex, keep it in domain/data layers before presentation.
- If network calls are needed, use the variant transport (Dio / axios / generated Swift `Client` / generated Kotlin `*Api` over Ktor) with interceptors and offline handling.
- If a critical user flow changes, add or update Maestro E2E coverage.
- If backend contracts are missing, coordinate with backend/API work.

### Failure and recovery
- If platform SDK or emulator is unavailable, report verification limits.
- If a permission or native capability is missing, add explicit platform configuration or document blocker.
- If tests fail, fix before handoff or report the failing check.

### Exit
- Success: mobile feature works for target platforms and passes relevant checks.
- Partial success: platform, simulator, dependency, or verification gaps are explicit.

## Logical Operations

### Actions
| Action | SSL primitive | Evidence |
|--------|---------------|----------|
| Inspect mobile architecture | `READ` | Domain/data/presentation files |
| Select state and platform strategy | `SELECT` | Riverpod/Bloc and platform constraints |
| Implement mobile code | `WRITE` | Widgets, screens, providers, clients |
| Validate lifecycle and permissions | `VALIDATE` | Dispose, permissions, offline behavior |
| Call verification tools | `CALL_TOOL` | Tests, builds, Maestro |
| Report result | `NOTIFY` | Final summary |

### Tools and instruments
- Flutter/Dart, React Native, Swift, or Kotlin Android stack
- Riverpod/Bloc, Dio, Hilt, Ktor, platform SDKs, Maestro
- Unit, widget, integration, and E2E test commands

### Canonical workflow path
Use the configured code-intelligence provider to locate files and inspect symbols
or content. For Serena, use `find_file`, `search_for_pattern`,
`get_symbols_overview`, and `find_symbol`. Native search is limited to the
provider exclusions and non-code paths permitted by the project's search policy.


Then run the project's mobile verification commands, typically unit/widget tests and Maestro E2E for critical flows.

### Resource scope
| Scope | Resource target |
|-------|-----------------|
| `CODEBASE` | Mobile source, tests, platform config |
| `LOCAL_FS` | Templates, snippets, resources |
| `PROCESS` | Build, test, emulator, simulator, E2E commands |
| `NETWORK` | Backend APIs when the feature integrates remotely |

### Preconditions
- Target mobile feature and platform scope are identifiable.
- Required SDKs, permissions, and API contracts are available or assumptions are stated.

### Effects and side effects
- Mutates mobile source, tests, and platform configuration.
- May affect permissions, app lifecycle, offline data, or performance.

### Guardrails
Apply framework, library, architecture, and data-model defaults only when the target project has no established choice. Scoped edits do not authorize a stack migration or unrelated infrastructure.
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. Use the platform transport with auth/retry/logging interception and offline handling: Flutter uses Dio, React Native uses axios behind TanStack Query, Swift uses generated `Client` middleware, and Kotlin uses Ktor plugins on the generated `*Api` client.
6. 60fps target; verify supported target platforms (Swift iOS needs iOS only; Kotlin Android needs Android only)
7. Use Maestro for E2E testing of critical user flows
8. Swift native: SwiftUI + `@MainActor @Observable` view models (Observation framework, iOS 17+) — non-isolated VMs mutating observed state from a `Task` are a Swift 6 strict-concurrency error
9. Swift native: use the existing API layer. When the project adopts OpenAPI generation, use its generated Client for covered endpoints; a UI-only edit does not introduce a generator.
10. Swift native: when response caching is required, use the existing Repository cache; for a new hyperoslo/Cache implementation, use a ResponseCache actor — cache DECODED models (never `HTTPBody`), serve stale-while-revalidate on reads, invalidate keys on writes; view models depend on a protocol seam, not the concrete service (see `variants/swift-ios/snippets.md` §10)
11. Swift native: follow `App/Core/Features/Shared` project layout
12. Swift native: iOS Human Interface Guidelines for all UI decisions
13. Swift native: XCTest or Swift Testing for units, XCUITest for critical flows; cancel work via structured `.task {}` (auto-cancels on disappear) — never in `deinit`, which is nonisolated and cannot touch `@MainActor` state under Swift 6 (isolated deinit requires Swift 6.2+)
14. Swift native: restore edge swipe-back at the route layer — nav-bar-hidden screens (`.toolbar(.hidden, for: .navigationBar)`) lose it, so register push routes via a `swipeBackDestination` wrapper, not per-screen (see `variants/swift-ios/snippets.md` §9)
15. Flutter: when offline response caching is required, use the existing repository cache; if adding Drift, read cached entities then revalidate (stale-while-revalidate), and invalidate/refresh affected rows on every write; cache decoded entities at the data layer, never at the Dio transport (see `variants/flutter/snippets.md` §3, §10)
16. React Native: preserve the existing server-state layer; for TanStack Query with explicit `staleTime`/`gcTime` — invalidate affected query keys on every mutation, persist account-scoped cache to MMKV only when offline persistence is required; screens consume query/mutation hooks, never call axios directly (see `variants/react-native/snippets.md`)
17. Kotlin native: Jetpack Compose + `@HiltViewModel` exposing one `StateFlow<UiState>` collected with `collectAsStateWithLifecycle`; network work in `viewModelScope`, `CancellationException` always rethrown
18. Kotlin native: use the existing API layer. When the project adopts OpenAPI generation (`org.openapi.generator`, `kotlin` / `jvm-ktor`), call the generated `*Api` for covered endpoints and keep the Ktor engine (OkHttp on device, `MockEngine` in tests) injected where the client is constructed — Ktor is an engine-agnostic layer, not an OkHttp replacement; a UI-only edit does not introduce a generator (see `variants/kotlin-android/snippets.md` §1, §3)
19. Kotlin native: when response caching is required, use the existing repository cache; for a new Room implementation cache DECODED models with explicit TTL, stale-while-revalidate on reads, upsert/delete on writes — never OkHttp `Cache` or Ktor `HttpCache`; view models depend on an interface seam, not the concrete repository (see `variants/kotlin-android/snippets.md` §8)
20. Kotlin native: follow the `app/{ui,data,di}` + `api-client` layout; type-safe Navigation Compose routes; Material Design 3; JUnit + `ktor-client-mock` contract tests, Compose UI tests or Maestro for critical flows

## References
- Execution steps (follow for the selected task): `resources/execution-protocol.md`
- Code snippets (Swift): `variants/swift-ios/snippets.md`
- Code snippets (Kotlin Android): `variants/kotlin-android/snippets.md`
- Code snippets (Flutter): `variants/flutter/snippets.md`
- Code snippets (React Native): `variants/react-native/snippets.md`
- Checklist (run before handoff): `resources/checklist.md`
- Error recovery: `resources/error-playbook.md`
- Tech stack index (all platforms): `resources/tech-stack.md`
- Tech stack (Swift): `variants/swift-ios/tech-stack.md`
- Tech stack (Kotlin Android): `variants/kotlin-android/tech-stack.md`
- Tech stack (Flutter): `variants/flutter/tech-stack.md`
- Tech stack (React Native): `variants/react-native/tech-stack.md`
- Screen template (Flutter): `resources/screen-template.dart`
- Screen template (Swift): `resources/screen-template.swift`
- Screen template (React Native): `resources/screen-template.tsx`
- API service template (Swift): `variants/swift-ios/api-template.swift`
- API service template (Kotlin Android): `variants/kotlin-android/api-template.kt`
- API service template (Flutter): `variants/flutter/api-template.dart`
- API service template (React Native): `variants/react-native/api-template.ts`
- Variant registry: `variants/README.md`
- Context loading: `references/_shared/core/context-loading.md`
- Clarification: `references/_shared/core/clarification-protocol.md`
- Context budget: `references/_shared/core/context-budget.md`
- Lessons learned: `references/_shared/core/lessons-learned.md` (matching prior failure or requested retrospective)
- Observability handoff: `../oma-observability/SKILL.md` §Integrations — offline queuing, crash analytics, battery-aware sampling

© First Fluke · MIT · first-fluke/oh-my-agent

Similar skills

All skills for Mobile →

oma-mobile by other authors comes first.

oma-mobile First Fluke oma-mobile — a mobile-focused skill: it builds screens and widgets in Flutter or React Native, wires camera, GPS, push and offline handling, then runs the checks. CX Codex +1 ★ 1,472repo stars mobile-development samhvw8 A mobile development reference for your agent: picking between React Native, Flutter and native, offline sync, push, biometrics and store releases. CX Codex +1 112installs senior-mobile borghei senior-mobile — a mobile development skill that runs in Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode. CX Codex +1 316installs maestro-e2e raphaelbarbosaqwerty Helps your agent write and debug Maestro E2E tests: login, signup, navigation, permission dialogs. Covers iOS, Android, Flutter, React Native and web. CX Codex +1 543installs mobile-app-ui-design ceorkm mobile-app-ui-design provides mobile UX and UI guidelines for coding agents. Helps generate mobile screens, components, and design flows that follow structured layout rules. CX Codex +1 13,200installs mobile-design sickn33 mobile-design is a Claude Code skill that reviews and guides iOS, Android, React Native, and Flutter interfaces during mobile UI work, checking touch targets, offline handling, and rendering performance. CX Codex +1 3,800installs mobile-developer VoltAgent Community mobile-developer — a subagent for React Native and Flutter apps that covers native features, offline-first architecture, and platform-aware performance work. CX Codex 7,777installs

From the same set69

The whole set →
oma-frontend oma-frontend is a Claude Code skill for building and editing frontend UI in React, Next.js, and TypeScript projects, including components, pages, styles, and client logic. CX Codex +1 ★ 1,472repo stars oma-backend oma-backend is a Claude Code skill for implementing server APIs, authentication, and application data access. It activates for endpoint, server-logic, and background-job tasks. CX Codex +1 ★ 1,472repo stars oma-recap oma-recap pulls conversation histories from AI tools across a chosen timeframe and organizes them into a themed project report. Useful for standups and understanding how work distributed across different AI assistants. CX Codex +1 ★ 1,472repo stars oma-tf-infra The oma-tf-infra skill creates and reviews Terraform code, plans, and cloud infrastructure. It covers IAM, networking, state, cost, and destructive-change risk. CX Codex +1 ★ 1,472repo stars oma-architecture oma-architecture — a skill for Claude Code and Codex to evaluate system boundaries and architectural tradeoffs. Runs during system design reviews, module boundary audits, and ADR authoring. CX Codex +1 ★ 1,472repo stars oma-design The oma-design skill shapes and audits a project’s design system, from DESIGN.md to accessibility and responsive guidance. Use it before frontend work or to review an interface. CX Codex +1 ★ 1,472repo stars oma-brainstorm oma-brainstorm — a skill for Claude Code and Codex designed for early feature exploration before task planning. Clarifies ambiguous requests one question at a time and compares technical options. CX Codex +1 ★ 1,472repo stars oma-orchestrator oma-orchestrator — a skill that automates spawning multiple specialist agents at once, coordinates them via MCP Memory, and tracks progress. CX Codex +1 ★ 1,472repo stars

Project sponsors

Companies that keep this analytics open