# Expo Skills: The Official Agent Skills for Expo and EAS, and How to Install Them

> Source: <https://explainx.ai/blog/expo-skills-official-ai-agent-skills-expo-router-eas-claude-code-codex-install-guide-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-10-28 00:00:00+00:00

**expo/skills is the Expo team's official collection of AI agent skills, a set of instruction files that teach coding agents how to build, deploy, upgrade and debug Expo apps and use Expo Application Services (EAS).** The MIT-licensed repository had about 3.3k stars, 215 forks and 150 commits on October 28, 2026, and was gaining stars quickly on GitHub's trending list. The [README](https://github.com/expo/skills?ref=explainx) says the skills give agents "focused Expo knowledge: when to use Expo APIs, how to structure common workflows, and which Expo, EAS, React Native, iOS, and Android constraints matter."

Because it comes from the framework's maintainers, it is worth a look if you build React Native apps with Claude Code, Codex or another agent. This guide covers what is inside, how to install it, which skills touch paid services, and what to check. It extends our wider coverage of skills in [our agent skills guide](https://explainx.ai/blog/what-are-agent-skills-complete-guide).

## Quick answers

| Question | Answer | 
|---|---|
| Who made it? | The Expo team (official) | 
| License | MIT | 
| Claude Code install | `claude plugin install expo@claude-plugins-official` | 
| Codex install | `codex plugin add expo@openai-curated` | 
| Other agents | `npx skills@latest add expo/skills --skill '*'` | 
| Updates | Plugins via marketplaces; skills CLI via `npx skills@latest update` | 
| Source of truth | Expo docs, Expo CLI, EAS CLI | 
| Paid parts | Skills that use EAS services are labeled and carry cost notes | 

## What skills are included?

The README sorts the skills into four groups, so the free versus paid boundary is clear.

**Start here.** `expo-overview` is the router and shared setup rules. Load it first for any Expo or EAS task, especially when a request is vague.

**Framework (open source).** These cover free Expo SDK and React Native work:

| Skill | Use it for | 
|---|---|
| expo-project-structure | Folder layout for a new app: src/, routes-only app/, screens, server code, platform files | 
| expo-router | File-based routes, links, native stacks, modals, sheets, native tabs, headers | 
| expo-animation | Reanimated, Gesture Handler, Expo Router and haptics for animation and gestures | 
| expo-native-ui | Native-feeling styling, semantic colors, controls, icons, media, effects | 
| expo-design-system | Token themes, component conventions and design-system drift audits | 
| expo-ui | @expo/ui native components, with SwiftUI and Jetpack Compose where needed | 
| expo-data-fetching | API calls, React Query, SWR, caching, offline support, loaders | 
| expo-dom | Expo DOM components for gradually reusing web code in native apps | 
| expo-web-to-native | Migrating a Next.js, Vite or CRA web app to native with Expo | 
| expo-module | Native modules and views in Swift and Kotlin, config plugins, autolinking | 
| expo-brownfield | Adding Expo or React Native to an existing iOS or Android app | 
| expo-dev-client | Development clients; local builds are free, EAS Build and TestFlight are paid | 
| expo-examples | Adapting integrations from the expo/examples repo | 
| expo-app-clip | iOS App Clip targets, AASA files, associated domains, Smart App Banners | 
| expo-upgrade | SDK upgrades, dependency conflicts, deprecated packages, cache cleanup | 

Phone outline with a grid of app squares representing Expo skills for building mobile apps with agents

**Services and paid distribution.** These skills "use paid Expo Application Services (EAS)" at their core: eas-app-stores (build and submit, TestFlight, profiles, versioning), eas-hosting (Expo websites and API routes, secrets, custom domains, Cloudflare Workers), eas-workflows (workflow YAML and CI/CD), eas-observe (launch, route, event and version metrics), eas-update (OTA publishing and runtime compatibility), eas-update-insights (rollout health, crash rates, payload size) and eas-simulator (run and drive your app on a remote iOS simulator or Android emulator, with a live browser preview for iOS only).

**Experimental.** `expo-migrate-module` migrates a Swift Expo module from the Modules API 1.0 definition DSL to the 2.0 macro API. Experimental skills ship in a separate expo-experiments plugin, and the README warns content "may change or be retired."

## How do I install it?

Pick the path for your agent.

```
# Claude Code (official plugin marketplace)
claude plugin install expo@claude-plugins-official

# Codex (OpenAI-curated marketplace)
codex plugin add expo@openai-curated

# Cursor, OpenCode, Copilot, Windsurf, Gemini, Cline, and others
npx skills@latest add expo/skills --skill '*'
```

The skills CLI asks where to install them; add `--agent <agent>` to target one. Run it from your project root, then restart or refresh your agent session so it discovers the installed SKILL.md files. To update, plugin installs use their marketplaces and the CLI route uses `npx skills@latest update`, or pass a skill name such as `expo-router` to update one.

## What can I ask the agent to do?

The README suggests prompts such as "Build a native-feeling Expo Router screen with tabs, modals, and animations," "Create an EAS workflow that builds previews on pull requests," "Help me upgrade this app to the latest Expo SDK," and "Check whether this EAS Update rollout is healthy." The agent chooses a skill from the task and each skill's description, so you rarely need to name one. If a request is vague, expo-overview routes it.

Release pipeline with a green block moving along a conveyor, representing EAS workflows and deployment skills

## What does the Expo MCP server add?

Skills teach an agent how Expo work gets done. The README adds that the Expo MCP server gives it "live access to actually do that work": read the latest Expo docs on demand, install compatible dependencies with `npx expo install`, trigger and monitor EAS builds and workflows, pull crash data from TestFlight, and screenshot a running app in the simulator. The expo plugin bundles the MCP configuration, so Claude Code and Codex installs wire it up automatically. For other agents, follow Expo's MCP setup guide. If MCP is new to you, start with our primer on [Model Context Protocol](https://explainx.ai/blog/what-is-mcp-model-context-protocol-guide).

## Why does it matter that it is official?

Community skills for frameworks go stale. An official set maintained by the framework team has two advantages. First, it tracks the platform: the repo has 150 commits, an eval harness submodule, an `expo-skill-eval` skill and EAS workflows, which suggests the team tests skills against fixtures such as a brownfield app. Second, it states its authority clearly: docs and CLIs stay the source of truth, and the skills only help agents apply them.

It also reflects a trend. Platform vendors now ship skills and plugins alongside docs, and distribute them through the Claude Code and Codex marketplaces. We tracked the same pattern in [Microsoft's Aspire templates with agent skills](https://explainx.ai/blog/microsoft-aspire-templates-repo-six-starters-agent-skills-aspire-new-guide-2026) and in the [Agent Skills foundation donation](https://explainx.ai/blog/anthropic-donates-agent-skills-agentic-ai-foundation-agentskills-io-70-platforms-2026).

## What should you watch for?

- **Costs.** The services skills touch paid EAS features. The README says every services skill opens with a costs and plan-limits note; read it before letting an agent trigger builds, hosting or simulators.
- **Free versus paid tiers.** expo-dev-client is a good example: local builds are free, but EAS Build and TestFlight are paid steps.
- **Agent permissions.** Skills that trigger builds and updates act on real projects. Use approvals for actions like publishing an OTA update, and consider a review layer such as[AgentBeam](https://agentbeam.com/?ref=explainx) from the explainx.ai team for stopping agents before dangerous actions.
- **Version drift.** Expo SDK moves fast. Check that the installed skills match your SDK version, and run the update command regularly.
- **Experimental skills.** Do not build workflows on expo-migrate-module until it graduates.
- **Feedback loop.** Each skill includes instructions to submit actionable feedback with`npx --yes @expo/agent-cli@latest feedback` . Confirm what that command sends before enabling it in a private repo.

## Which skills help with which job?

Group them by the stage of an app's life and the pattern becomes clearer.

**Starting a project.** expo-project-structure and expo-router decide where files live and how screens connect. Getting this right early matters because agents tend to copy whatever structure they see first, and a messy layout compounds. expo-examples helps when your idea matches an existing integration in the examples repo, so the agent adapts working code instead of inventing it.

**Making it feel native.** expo-native-ui, expo-animation and expo-ui address the gap between a working screen and one that feels like it belongs on iOS or Android: semantic colors, native tabs and sheets, haptics, and platform components in SwiftUI and Jetpack Compose. expo-design-system adds a token theme and audits for drift when screens stop following it.

**Reusing code you already have.** expo-dom and expo-web-to-native are for teams with an existing web app. expo-brownfield is for teams with an existing native app that want to add Expo or React Native gradually, which is a common real-world situation that generic coding prompts handle poorly.

**Shipping and operating.** eas-workflows, eas-app-stores, eas-update, eas-update-insights and eas-observe cover the release path: CI, store submission, over-the-air updates, rollout health and metrics. These are the skills where a wrong action costs money or affects users, so they deserve the most careful permissions.

**Maintaining.** expo-upgrade is the one many teams will reach for first. SDK upgrades involve dependency conflicts, deprecated packages and cache problems, and a skill that encodes the upgrade path is a clear fit for an agent that can run commands and read errors.

None of these replaces reading the release notes for a major SDK, which live in the [Expo documentation](https://docs.expo.dev/?ref=explainx). They make the agent a better assistant while the docs stay authoritative, which is exactly the framing the README chooses.

## A sensible first experiment

Install the plugin in a throwaway Expo project. Ask the agent to scaffold a tabbed Expo Router app, then to add a modal and a gesture-driven animation, and watch whether it follows the project-structure conventions the skills describe. Then try a read-only task, such as asking it to check the health of an EAS Update rollout, before allowing any action that changes state. Compare the result with the same prompts on a clean agent session without the skills; the difference tells you whether the skills earn their context cost.

## Related reading

*Details reflect the repository README and star counts as of October 28, 2026; skills and install commands change.*