expo-web-to-native
Migrate an existing web React app to a native iOS/Android app with Expo
Install / Use
npx skills add expo/skills --skill expo-web-to-nativeInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of expo-web-to-native
expo-web-to-native scores 88/100 on our quality scale, 1890th of 4,698 Development & Engineering skills we index (top 41%).
Its SKILL.md is 10 KB long, well organised into 13 sections with 2 code examples: a thorough specification that gives an agent plenty to work with.
With 2,602 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so expo-web-to-native is actively maintained.
- Our last check on 2026-11-01 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit β read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-01. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk β read a skill before letting an agent act on it.
expo-web-to-native compared with similar skills
All 4 of these similar skills score higher than expo-web-to-native; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| expo-web-to-native (this skill)by expo | 88 | 2.6k | 53d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| lobehubby lobehub | 100 | 85.6k | today | MCP Server |
Frequently asked questions
- How do I install expo-web-to-native?
- Run
npx skills add expo/skills --skill expo-web-to-native. The install tabs above show the steps for each supported agent. - Which AI agents does expo-web-to-native work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is expo-web-to-native safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is expo-web-to-native still maintained?
- The repository was last updated about 2 months ago, so expo-web-to-native is actively maintained.
Skill content
View source on GitHubname: expo-web-to-native
description: Framework (OSS). Migrate an existing web React app to a native iOS/Android app with Expo. Use when the user wants to turn a website into a mobile app, port a Next.js/Vite/CRA React codebase to React Native, reuse web code on native incrementally, or asks how web idioms (the DOM, CSS, React Router, localStorage, window) map to native. This is the end-to-end migration guide; use the expo-dom skill for the DOM-component mechanism itself.
version: 1.0.0
license: MIT
Web to Native
A web React app does not convert to native β there is no transpiler. It migrates, screen by screen, the way a strangler fig grows around a tree and slowly replaces it: stand up a native shell, run the whole web UI inside it on day one, then strangle each screen into native in priority order. This skill is the spine that orders the work; each step hands off to an existing Expo skill rather than re-explaining it. It operationalizes Expo's From Web to Native with React β read that for the why.
flowchart TD
A1[1 Β· Assess: write the worklist] --> A2[2 Β· Scaffold Expo shell]
A2 --> A3[3 Β· DOM-component shell<br/>Β· expo-dom Β· SHIP DAY ONE]
A3 --> A4[4 Β· Strangle screens to native<br/>highest-value first Β· expo-router]
A4 -->|more screens| A4
A4 --> A5[5 Β· Wire data / auth / storage<br/>Β· expo-data-fetching]
A5 --> A6[6 Β· Ship Β· eas-app-stores]
Principles
- Migrate, don't rewrite. Never big-bang it; every step keeps the app shippable.
- Ship on day one. The web UI runs in a DOM-component shell (step 3) before anything is nativized β that's the milestone; everything after is polish.
- Strangle by value. Nativize the hot screens; leave the rest in the webview. Each DOM screen carries a ~2 MB web runtime β reason enough not to ship everything as DOM.
- Nativize means redesign, not reskin. A strangled screen should look like Apple/Google shipped it, not the web page reskinned. Reach for
@expo/uifirst - it renders real SwiftUI/Compose, so it feels exactly like the OS; styled RN primitives are the fallback for custom layouts only. Plus platform navigation (expo-router: NativeTabs, large titles), liquid glass and native components via@expo/ui, and mobile UX (sheets, swipe, haptics). The webβnative pattern map is./references/native-patterns.md. If it still feels like a website, you ported instead of redesigned. - Verify by running, not compiling. A clean build proves nothing (a blank webview compiles fine). Run each screen β but judge content and behavior against the web original, not pixels (a nativized screen should look more native, not identical).
- Orchestrate, don't reinvent. Each step routes into an existing skill. The value here is the order and the gotchas β the idiom-by-idiom mappings live in
./references/false-friends.md.
Run it as a loop (recommended)
The migration is a long repeat-until-done loop, so the first move is to write the goal objective and launch it β not to grind screens by hand. Fill the objective in ./references/run-as-goal.md for this app and present it; it re-reads this skill every iteration, so each /goal turn reloads the playbook + worklist and drives the next screen (it even self-bootstraps the assess step). Then run /goal with it β or, if the harness can't loop, write it to migration-goal.md and have the user launch it. The steps below are what each iteration does; run them by hand only if you're not looping.
The migration
No repo to migrate - just building native fresh as a web dev? You don't need these steps: use
expo-router, and keep./references/false-friends.mdopen for the webβnative idiom map. Everything below assumes an existing web app.
1. Assess β write the worklist
Read the repo and produce migration-progress.md, the durable worklist the rest of the migration checks off. Make two cuts:
- Screens vs backend. Page routes (
page.tsx) are screens you migrate; server routes (route.ts), the ORM, and auth handlers stay server-side. Decide the backend once: keep it deployed (the native app becomes an HTTP client) or move it to EAS Hosting (eas-hosting). - Bucket each screen by how it should land: port-as-is (presentational β ships in a DOM webview), nativize-now (hot, or needs native feel β gestures, lists, keyboard), nativize-later, or hybrid (a native shell around a web sub-tree, e.g. a chat list wrapping a markdown renderer).
Note the framework signals as you read β RSC vs client, Tailwind/shadcn, where data is fetched β since they decide how each screen ports (false-friends has the mappings; async Server Components in particular must be split into a client fetch + a presentational component before they can move). Flag third-party services/SDKs too β browser SDKs don't carry over (false-friends β Services & SDKs); payments especially is a fork, not a swap (in-app digital goods must use store IAP via RevenueCat, ~30% β not Stripe), a business-model call to make now, not at App Store review. The worklist is only trustworthy once every route is sorted and every screen bucketed.
2. Scaffold the shell
create-expo-app, then mirror the web routes in Expo Router β Next's tree maps almost 1:1 (note [id]/page.tsx β [id].tsx, and routes may live in src/app/). Empty screens, one per route.
3. Shell it in DOM components β the day-one milestone
Bring every screen over as a DOM component ('use dom', per the expo-dom skill) rendered by its native route, so the whole app runs on a phone before anything is nativized. Expect per-screen edits - unwrapping Server Components, swapping framework imports (next/link), carrying the styling over - all covered in false-friends. Then verify by running (below); this is shippable to TestFlight as-is.
4. Strangle screens to native β by value
Walk migration-progress.md top-down. For each screen, redesign it native - don't port the web layout. Reach for @expo/ui first (real SwiftUI/Compose - buttons, lists, sheets, pickers, sliders; ./references/native-patterns.md maps which web pattern becomes which native component), then platform navigation (expo-router - NativeTabs, large titles) and mobile UX (swipe, haptics, momentum/inverted scroll); RN primitives only for custom layouts. Consult ./references/false-friends.md for each idiom. @expo/ui and DOM components both run in Expo Go (SDK 56+) - a dev build (the expo-dev-client skill) is only needed for custom native modules. Verify content and behavior against the running web original (the look should become more native), then check it off. One screen per pass, app shippable throughout. It's a loop over a durable worklist, so it can run unattended - hand it to a goal loop (./references/run-as-goal.md).
5. Wire data, auth, and storage
The web data layer doesn't survive the move - relative fetches, cookie sessions, localStorage, and env vars all change (swaps in false-friends). Use expo-data-fetching for requests and caching; add eas-hosting if the backend moved to EAS Hosting.
6. Ship
eas-app-stores for the store builds (App Store / Play / TestFlight), EAS Update for OTA pushes after.
Verify by running, not compiling
A green expo export proves a screen bundles, not that it renders β a screen can build and still render blank or mis-render. So after the shell and after every nativized screen, compare the two running apps for the same route:
- Web original β capture it with
agent-browser(vercel-labs CLI):openthe route,snapshot --jsonthe accessibility tree,screenshot. - Native β drive the simulator with
argent:describe/debugger-component-treefor structure,flowto replay the check each pass.
Pass on parity of content and behavior β not pixels: a nativized screen should look more native than the web, never identical (the DOM-shell stage is the exception β there it is the web UI, so it should match). Feel is part of native and can't be screenshotted β for screens with transitions or gestures, capture a short recording, not just a still (see native-patterns.md β Feel). This loop is opinionated about its tooling: if agent-browser or argent isn't installed, ask the user and install it before proceeding β don't fall back to manual screenshots. Full recipe and setup in ./references/verify-on-device.md.
References
./references/false-friends.mdβ web idiom β native equivalent + the gotcha for each. The lookup for steps 3β5, and for any web dev unlearning idioms../references/native-patterns.mdβ web UX pattern β native redesign (@expo/ui-first). The step-4 redesign playbook so screens feel OS-native, not reskinned../references/verify-on-device.mdβ the two-agent parity recipe: drive the web app (browser agent) and the native app (argent), open the same route, compare../references/run-as-goal.mdβ a ready-shaped, migration-specific goal objective for driving step 4 unattended (re-reads this skill each iteration).- Expo β From Web to Native with React β the canonical guide this skill operationalizes.
Submitting Feedback
If you encounter errors, misleading or outdated information in this skill, report it so Expo can improve:
npx --yes submit-expo-feedback@latest --category skills --subject "expo-web-to-native" "<actionable feedback>"
Only submit when you have something specific and actionable to report. Include as much relevant context as possible. If an AI agent repeatedly failed or the user had to take over an Expo task, load the expo-skill-feedback skill and follow its eval-candidate flow instead of reusing the command above.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code β from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
lobehub
85.6kπ€― LobeHub - Super-Agents on Your Team. Add super-agents to the chats your team already uses.They take on work by themselves and get better every week.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit β see the Safety scan above for what the skill file itself contains.
