Build a Mobile App with Claude Code: The A-Z Guide (2026)

- Mobile tooling moves fast (Expo SDK, EAS), so I use @latest-style commands to keep this guide from going stale.

Can Claude Code build a mobile app?

Yes - Claude Code can build a mobile app, and it does the job well if you stick to a JavaScript stack. Claude Code is Anthropic's agentic command-line tool: it reads your whole repo, writes and edits files, runs terminal commands (like npx expo start or eas build), reads the error logs, and iterates on its own until the app runs (Anthropic - Claude Code docs, 2026).

That makes Claude Code an ideal partner for vibe-coding a phone app: you focus on what the app should do, and it handles the repetitive typing. With React Native + Expo, the entire chain - scaffolding, running the dev server, packaging an .apk or a TestFlight build - is CLI commands, which is exactly where Claude Code shines.

Let me be blunt: Claude Code does not replace your understanding of the product. It is fast at the "build a mobile app with AI" part at the JS/UI layer, but deep native modules (Swift/Kotlin) and the store-review process still need you. If you are brand new, read what Claude Code is first to see how it works.

Compared with typing out each file by hand or copy-pasting from a chat window, the biggest difference is that Claude Code works inside your project: it sees the Expo Router folder structure, reads package.json to know which libraries you use, and can run the dev server and read back the errors itself. The "edit, run, read the error, fix again" loop stays closed right there in the terminal, so you rarely bounce between a browser and an editor. That working style is exactly why it fits mobile - where every change needs a re-run on Expo Go to verify.

Prep: pick a stack and set up your environment

Before you type a single command, pick a stack. Here is the matrix I use to decide - the same logic as the mobile-app skill in AgentKit:

This guide follows Expo + React Native because it is the fastest route to a running app. What you need:

• Node LTS (latest release, so npx works).
• Expo Go installed on a real phone (iOS App Store / Google Play) - so you can see the app instantly without a build.
• Claude Code installed on your machine - see the Claude Code install guide.
• macOS is only required to build the iOS version for the App Store. Everything else (coding, testing on Android, dev on Expo Go) runs fine on Windows/Linux.

You do not need Xcode or Android Studio installed to start - Expo Go handles the test runs, and the native build step happens in the cloud through EAS (covered in Step 6).

Step 1 - Plan the app with Claude Code

Do not tell the AI "code me an app" and let it charge into typing. The most valuable move is locking scope before there is a single line of code. I open Claude Code in plan mode and describe the app I want - for this guide I am building a small habit-tracker: a list of habits, a daily check-off, and a streak view.

The prompt I use, roughly:

I want to build a habit-tracker mobile app with Expo + React Native.
Before writing code, propose:
1. A list of screens (list, detail, add/edit a habit, stats)
2. A data model (habit, daily tick log)
3. State + local storage (offline-first)
Do not write code yet. Just settle the plan for me to review.

Claude Code returns a screen map plus a data model for you to review. Fixing things at the planning layer is far cheaper than fixing them once 20 files exist. To go deeper on this technique, see how to plan a project with Claude Code.

Step 2 - Scaffold the Expo project + a CLAUDE.md for mobile

Once the plan is settled, let Claude Code (or you) run the project-creation commands:

npx create-expo-app@latest habit-tracker
cd habit-tracker
npx expo start

create-expo-app sets up the structure with Expo Router (file-based routing, like Next.js). npx expo start boots the dev server and shows a QR code - scan it with Expo Go on your phone and the app runs immediately, no build required.

The single thing that makes the biggest difference to output quality is a CLAUDE.md for mobile. This is the "conventions file" Claude Code reads every time it works - place it at the repo root. My copy-paste template:

# CLAUDE.md - Habit Tracker (Expo + React Native)

## Stack
- Expo (latest SDK) + React Native + TypeScript
- Routing: Expo Router (file-based, app/ directory)
- State: Zustand
- Local storage: AsyncStorage (offline-first, no network dependency)

## Code conventions
- Function components + hooks; NO class components
- File names kebab-case; components PascalCase
- Absolute imports via the @/ alias (configured in metro/tsconfig)
- Style with StyleSheet.create; no hardcoded colors - use the theme in constants/

## Working rules
- Before committing: run `npx tsc --noEmit` and `npx expo lint`, fix all errors
- Each screen lives in app/; split logic into hooks/ if over 100 lines
- Never hardcode API keys; read from env vars / expo-constants
- After a UI change, remind me to re-test on Expo Go

This file keeps Claude Code on the same conventions across the whole session - instead of building things a different way each time. To understand the CLAUDE.md mechanism in depth, see the CLAUDE.md guide.

Step 3 - Build the screens (UI) with Claude Code

This is where vibe-coding pays off. The rule I always keep: build one screen at a time and check it on Expo Go after each one. Do not let the AI spit out six screens at once and then sit there untangling them.

The order I follow for the habit-tracker: list screen, then detail screen, then the add/edit form. The prompt for the first screen, roughly:

Build the habit list screen (app/index.tsx):
- FlatList rendering the habits from the Zustand store
- Each item: habit name, current streak, a "tick today" button
- Empty state: text "No habits yet, add one now"
- Tapping an item navigates to app/habit/[id].tsx (Expo Router)
Follow the conventions in CLAUDE.md. When done, tell me to open Expo Go to check.

After each screen, re-scan the QR in Expo Go to see it for real. If something is off (spacing, color, navigation), describe it to Claude Code and let it keep fixing - this loop is very fast thanks to hot reload. For the interface-building part, the UI prompting technique is identical to the web; see how to build React UIs with Claude Code and UI/UX tips for working with Claude Code.

Step 4 - Add state, data, and a backend

The app has a UI now, but it does not "remember" anything. Time to wire up data. For a small-to-medium app I use Zustand for state and AsyncStorage for local persistence - and the most important part is offline-first: mobile networks are flaky, so the app has to work when the signal drops and sync later.

Ask Claude Code to build the store + persistence:

Create a Zustand store (store/habits.ts):
- state: list of habits + daily tick log
- actions: addHabit, toggleTickToday, computeStreak
- persist everything to AsyncStorage (offline-first)
- restore state on app launch
Write full TypeScript types alongside it.

When you need multi-device sync or logins, that is when you add a backend. A quick, lightweight option is a backend-as-a-service (Supabase, for example) for auth + database; Claude Code can write both the API-call layer and the schema. If you would rather stand up your own API, see building a backend API with Claude Code; for the table design, there is working with databases using Claude Code.

One practical tip: ask Claude Code to separate the storage layer (store + persistence) from the UI layer from the very start. Later, when you swap AsyncStorage for a real backend, you only touch one place instead of digging through every screen. This is also the moment to have it write a few small computation functions (like computeStreak) with tests, because date logic is easy to get subtly wrong.

A security rule not to skip: never hardcode API keys in app code (they are easy to expose when the app is decompiled) - use environment variables and, for sensitive data, store it via Keychain (iOS) / KeyStore (Android). If the app has a login screen, prefer OAuth2 + JWT and consider biometric unlock (Face ID / fingerprint) for a smoother mobile experience.

Step 5 - Debug and test on a real device

The most expensive lesson every mobile beginner learns: the simulator lies about performance. It runs on your beefy computer CPU so everything feels smooth; on a mid-range phone the jank, battery drain, and slow loads finally show up. Always test a near-release build on a real device.

How to debug with Claude Code: paste the raw error log (from the Expo terminal or the red error screen in the app) into the session and let it read and fix it. It follows React Native stack traces pretty well. A few mobile-specific errors you will hit often:

• Stale Metro bundler cache: you edit code but the app does not change - run npx expo start -c to clear the cache.
• Wrong Expo SDK version: a library is incompatible with the SDK - use npx expo install <package> (it picks the SDK-matching version) instead of npm install.
• Native module needs a rebuild: you add a library with a native part - it will not show up in Expo Go; you have to build a development build (npx expo run:android / run:ios).

For other odd errors from the tool itself, see the roundup of common Claude Code errors and how to fix them.

Step 6 - Ship to the App Store and Google Play (EAS Build)

Expo Go is for dev only. To get a real installable file or to publish to a store, use EAS Build - Expo's cloud build service, so you can build iOS even without macOS.

npm install -g eas-cli
eas login
eas build:configure
# Build an internal build for testing:
eas build --profile preview --platform android # produces an .apk
eas build --profile preview --platform ios # needs an Apple Developer account

Once you have a build:

• iOS: submit through TestFlight for internal testing, then submit to the App Store. You need the Apple Developer Program at 99 USD/year (Apple Developer, 2026).
• Android: use Google Play internal testing first, then widen gradually Closed to Open to Production. The Google Play developer registration fee is a one-time payment when you create the account.

The release strategy I recommend: do not push straight to production. Follow the staged rollout ladder - an internal build for a few people, then closed testing for a larger group, then open/production. Each rung is a chance to catch bugs on real devices before it reaches the crowd. Claude Code can help with the eas.json config (the build profiles) and automation scripts, but the "when do I move up a rung" decision is yours.

An honest heads-up so your plan does not break: App Store review usually takes a few days and can be sent back if it violates a guideline - this is a human step, and no AI shortens it. To make the packaging/publishing flow smoother, see deploying apps with Claude Code. Configure EAS in detail per the official docs (Expo - Claude Code docs, 2026).

Speed it up: the ak-mobile-development skill built into AgentKit

To avoid confusion: "AgentKit" here is the skill/agent kit for Claude Code at agentkit.best (used via the ak CLI) - different from OpenAI's AgentKit product.

If you would rather not write your own CLAUDE.md and pick mobile conventions from scratch every time, the Engineer Kit (which includes the mobile skill) ships the ak-mobile-development skill: the framework-selection matrix, an offline-first default, the EAS Build workflow, and an OWASP mobile security checklist - Claude Code reads it directly and applies it. The Engineer Kit is currently 99 USD (the site lists no recurring fee) with lifetime updates and a money-back guarantee. Want the big-picture view first? Read what AgentKit is or just check out AgentKit (20% off via link). It is not required - you can absolutely do all of this with the template from Step 2.

The real limits of building a mobile app with Claude Code

So you set your expectations correctly, here is where Claude Code falls short - the stuff no competitor will admit:

• Deep native modules: complex Swift/Kotlin code (Bluetooth, advanced camera, background processing) is where the AI slips up, and you need to understand native yourself.
• iOS demands the Apple ecosystem: building/signing iOS needs macOS or a cloud service (EAS) plus a paid Apple account - AI does not get around this constraint.
• Store review is outside the AI's reach: Apple/Google review by hand; no "prompt" gets your app approved faster.
• Scope creep is easy: if you skip Step 1 (planning), the app balloons out of control. A tight plan is the cheapest way to avoid it.

Frequently asked questions (FAQ)

Can I build an iOS app with Claude Code without a Mac?

Yes. You code and test on Expo Go from Windows/Linux as normal, then use EAS Build (Expo's cloud build) to produce the iOS version without a Mac. You just need a paid Apple Developer account to submit to TestFlight/the App Store.

Should I use Expo or bare React Native?

Beginners should start with Expo: fast setup, instant testing through Expo Go, cloud builds via EAS. Only move to bare React Native when you need a native module that Expo does not support.

Can I build a mobile app with Claude Code if I cannot code?

You can build a simple app vibe-coding style, but you should still understand the basics: reading errors, knowing what the app should do, and being able to review the results. With no coding knowledge at all, debugging is hard and scope creep is likely.

Can Claude Code build a Flutter app?

Yes, Claude Code writes Dart/Flutter well. But this guide recommends Expo + React Native because the CLI command chain suits the agentic workflow better, letting the AI run and fix things on its own.

How long does it take to publish an app to the stores?

The code itself can be done in a few sessions. Review is the bottleneck: the App Store usually takes a few days and can send you back; Google Play is generally faster. It is a human process, not something AI shortens.

How much does it cost to build and release an app?

The code itself is free (Expo and React Native are open source). Main costs: the Claude Code plan you use (Pro at 20 USD/month and up), Apple Developer at 99 USD/year if you go to the App Store, and the Google Play registration fee when you publish on Android.

Conclusion + next steps

To recap the six steps: plan, scaffold Expo + CLAUDE.md, build screens one at a time, add state/data, test on a real device, and ship through EAS. Claude Code handles the typing; you own scope and result review. Next steps: go deeper on building UIs with Claude Code and the deploy workflow. And if you want to skip writing your own mobile conventions, AgentKit for Claude Code (20% off via link) ships a ready-made skill so you can start faster.