Short version
To build mobile apps with AI, you need three tools. Skills are instruction files (a SKILL.md the agent reads when a task needs them), so they stay cheap on context. MCP servers connect the agent to external services (build logs, dashboards, local simulator control) at the cost of loading tool definitions up front. The AI workflow is how you manage the conversation: keep each thread under about half the context window and branch by task. Add skills first, connect one MCP, then watch your context.
Agents cut typing cost on both dual-native and Expo paths. Expo still wins when you want one native ship path for iOS and Android, current Expo APIs via Skills and MCP, and EAS for build, update, and submit. For why that path exists (and when dual native still wins), see Why Expo is a great fit for new and existing apps. Coming from web React? Pair with From web to native with React.
This post is harness-agnostic: Cursor, Claude Code, Codex, and similar agents that support skills and MCP. Expo MCP Server and Expo Skills are docs and tooling for agents. They are not a separate "Expo Agent" product.
Scaffold the running example
Start with create-expo-app (habit tracker as the walkthrough app):
Use bunx / bun if that is your default. You get a running tabs app. The rest of the post shows how skills, MCP, and workflow turn that into an AI-assisted native ship loop.
Skills: instruction manuals for your AI
A skill is a folder of instructions an AI coding agent reads when a task calls for it. The minimum is a single SKILL.md. You can add references and scripts, but markdown alone is enough. Skills work across agents that support them, including Claude Code, Cursor, and Codex.
The Expo team maintains skills for building and shipping Expo apps. Browse expo.dev/skills or the expo/skills repo. Install with the skills CLI (example):
Pick individual skills or a broad set. Scope them to the project unless you live in mobile repos daily. Progressive disclosure matters: a skill exposes a short description up front; full instructions load only when the task needs them. That is why skills stay cheaper than MCP on context.
Two ways to invoke a skill
- Explicit: call it by name (slash command in Claude Code / Cursor conventions; Codex often uses
$). - Autonomous: the agent matches skill descriptions to your ask. Every description loads into every conversation, so do not hoard unused skills.
Example intent (after installing UI skills): ask the agent to implement native tab styling with the relevant Expo UI skill loaded. Prefer current @expo/ui / skill names from expo.dev/skills over stale one-off examples at publish time.
Let the agent find skills
Ask it to find a skill for performance or best practices, then install locally if the recommendation fits. Community directories exist; treat them as optional, not required for the Expo loop.
MCP servers: give the AI hands outside the editor
Skills stop helping when the answer lives outside the repo (EAS build logs, dashboard state, a running simulator). MCP (Model Context Protocol) connects the agent to those services so it can read and act.
The Expo MCP server exposes EAS builds, workflows, logs, and related project actions for agents with an Expo account. Install and auth from expo.dev/ai (and current docs linked there). Claude Code users can enable the Expo plugin that bundles skills and MCP; other harnesses follow their MCP config pattern. Authenticate with the harness /mcp (or equivalent) flow after install.
Server tools vs local tools
- Server capabilities (default): act against your Expo/EAS project (builds, workflows, logs).
- Local capabilities (opt-in): install
expo-mcpin the project so the agent can drive a local simulator (screenshots, taps, logs, Router sitemap). Follow the installer notes for yourstartscript.
Ask the agent to investigate a failing iOS build, propose a fix, and verify before returning. Run npx expo-doctor (or npx expo doctor) first: it often catches dependency mismatches before you burn tokens.
MCPs are token-heavy
MCP loads tool definitions up front. Add an MCP only when the project uses that service. Prefer Skills for "how to build X"; prefer MCP for "read or act on a system the repo cannot see."
Optional specialized local debugging tools from the ecosystem (for example Software Mansion Argent) can sit beside Expo MCP when you need broader multi-target automation. They are not required for the three-tool spine.
Skills vs MCP (at a glance)
| Skills | MCP server | |
|---|---|---|
| What it is | Instruction files (SKILL.md) read on demand | Connection to an external service the agent can read and act on |
| Context cost | Low (short description until needed) | Higher (tool definitions load up front) |
| Best for | How to build, upgrade, or debug in-repo | Build logs, dashboards, simulator control |
| Install scope | Add many; keep descriptions honest | Add sparingly; only services this project uses |
The AI workflow (context discipline)
Having skills and MCP is not enough if the conversation is a mess. Three failure modes:
- Not enough product context. Treat the agent like a sharp junior: specify the outcome, constraints, and design intent. Skills encode platform how-to; you still own the product ask.
- You do not know what you want yet. Use a planning skill or a dedicated ideation thread before stack and implementation threads. Leave tech stack out of the first pass.
- Context bloat. Past roughly half the context window, quality drops and cost rises. One conversation, one outcome. Branch (or fork) when the job changes: plan, then stack, then build, then a bug branch.
Practical rule: stay under about 50% context. Use a status line if your harness supports it. Resume clean threads instead of one endless chat.
Where to start
- Add Expo skills from expo.dev/skills.
- Connect one MCP: Expo MCP from expo.dev/ai.
- Watch context: branch by task; keep each thread focused.
That is the three-tool spine for AI-built Expo apps on one native ship path. Deeper "why Expo vs dual native + AI" lives on Why Expo is a great fit for new and existing apps. Web-to-store handoff lives on From web to native with React.
FAQ
What do you need to build mobile apps with AI?
Skills (SKILL.md instruction files), an MCP connection for services outside the repo (Expo MCP for EAS/logs/simulator), and context discipline (focused threads, roughly under half the window). Scaffold with create-expo-app, add skills, connect one MCP, manage the conversation.
What is an Expo skill?
A folder with a SKILL.md that teaches an agent how to build, upgrade, or debug Expo apps. Official set: expo.dev/skills. Works with Claude Code, Cursor, Codex, and other skill-capable agents.
What is the Expo MCP server?
A Model Context Protocol server that lets an agent use your Expo/EAS project (builds, workflows, logs) and, with local tools, drive a simulator. Install and account requirements: expo.dev/ai and linked docs.
Are MCP servers expensive on context?
Relative to skills, yes. Tool definitions load up front. Install only for services the project uses.
Do agents make dual native and Expo equally good?
Agents reduce typing cost on both paths. Expo still concentrates one TypeScript app, Skills/MCP for current Expo APIs, and EAS Build / Update / Submit on one ship path. Dual native still wins when shared UI is thin or the org requires separate stacks. See the Why Expo FAQ for the longer answer.
Is there an Expo Agent product?
No. Expo ships Skills, MCP, and docs (llms.txt) so your existing coding agents work better with Expo. Use the agent you already prefer.
Where to go next
- Skills: expo.dev/skills
- AI / MCP entry: expo.dev/ai
- Why Expo: Why Expo is a great fit for new and existing apps
- Web to native: From web to native with React
- Docs for agents: docs.expo.dev/llms.txt
