Build an app with Claude Code: iPhone tutorial

Building an app with Claude Code: the short answer

To build an app with Claude Code, you need paid access to Claude Code (a compatible subscription or pay-as-you-go Console), Node.js, an iPhone with Expo Go and an Expo project. You write a CLAUDE.md file that describes your stack and your rules, you ask for one screen at a time, you test each screen on your iPhone, then you send the app to TestFlight with EAS.

This tutorial complements my guide build an iOS app with AI, which explains what AI does well and what it misses. Here we get practical: the commands, the files, the prompts.

I code my iOS apps with Claude Code and Cursor every day. My stack: React Native, Expo, EAS, RevenueCat and Supabase. Solys, an alarm clock with mini-games, and TradaZen, a trading practice app, are live on the App Store. Nolera and Clic were rejected by Apple, then fixed. Everything below comes from that work.

To see this method applied to a published app, I documented TradaZen's journey, from the first commit to Apple's rejections and the pivots. That case study complements the steps in this tutorial.

Step 1: Get the prerequisites together

Before the first command, check that you have all of this.

A paid Claude account

Claude Code isn't included in claude.ai's free plan. According to Anthropic's documentation, you need a Pro, Max, Team, Enterprise or Console account. The Pro plan is enough to get started, within its usage limits.

Node.js and a terminal

Expo requires Node.js in its LTS version, on macOS, Windows or Linux. Claude Code runs on macOS 13 or later, Windows 10 or later and the main Linux distributions.

An iPhone and Expo Go

Install Expo Go from the App Store on your iPhone to try your first screens without compiling your own app. Before creating the project, check which SDK version is compatible with your setup on the Expo Go page. The latest SDK and the version distributed on the App Store aren't always available at the same time: Expo notably documented this gap in May 2026. So don't start from a version number you found in an old tutorial. To use your own native modules, plan for a development build.

A Mac? Not required

iOS builds are compiled on Expo's servers with EAS Build, using the Xcode version your Expo SDK picks (ITMS-90725), and EAS Submit works on macOS, Linux and Windows. So you can get all the way to TestFlight from a PC. The guide publish an iOS app without a Mac walks through that pipeline.

An Apple Developer account, later

You don't need one to code and test in the App Store version of Expo Go. It becomes mandatory when you send your app to TestFlight. We'll get back to it in step 7.

Step 2: Install Claude Code

On macOS, Linux or WSL, the method Anthropic recommends is the native installer:

curl -fsSL https://claude.ai/install.sh | bash

On Windows, in PowerShell:

irm https://claude.ai/install.ps1 | iex

Then check that the install worked:

claude --version

If you prefer npm, the command is npm install -g @anthropic-ai/claude-code. Don't put sudo in front of it, the documentation explicitly advises against it.

The first time you run claude, a browser opens so you can sign in to your account. After that, you just write in plain language: Claude reads your files, suggests changes and runs commands, with your approval.

Step 3: Create the Expo project

Go to the folder where you keep your projects and run:

npx create-expo-app@latest my-app
cd my-app
npx expo start

If the tool asks you to choose between compatibility with the App Store version of Expo Go and the latest SDK, pick compatibility for this exercise. Either way, check that the version created is supported by the Expo Go installed on your iPhone before going further. You can set up a development build when your project needs one.

A QR code shows up in the terminal. Scan it with your iPhone's camera: the app opens in Expo Go. One detail often trips people up the first time: Expo Go only opens your project if Expo CLI and Expo Go are signed in to the same Expo account. Run npx expo login on your computer and sign in with the same account in the app.

Why Expo rather than Swift? Claude knows React Native very well, and you can test without a Mac. I explain this choice on the page React Native and Expo for a mobile app.

Keep one Expo Go limitation in mind: it only contains the native modules it already ships with. As soon as you add a native library it doesn't know, in-app purchases for example, you'll need a development build. That's not a problem for your first screens.

Pick the right test environment

Expo Go, a development build and TestFlight don't prove the same thing. Expo describes the development build as your own test app, with the native modules your project needs.

What you want to check	Where to test	What the test doesn't cover
Display a first screen and try its navigation	Expo Go, with a compatible SDK	The behavior of native modules missing from Expo Go
Use a native library added to the project	A development build that includes this library	The distributed version or its acceptance by Apple
Go through the tester app, then test its purchases	A build sent to TestFlight and correctly configured products	A real customer payment or approval for release on the store

Before adding a dependency, ask Claude: "Is it compatible with my SDK and my current test environment? Do I need to rebuild the app? Back up your answer with the documentation." You'll avoid spending an evening fixing a module Expo Go simply can't load, or an SDK rejected at upload for non-public API.

Step 4: Write the project's CLAUDE.md file

This is the step with the best payoff. Claude Code can keep a project memory, but you have to spell out its rules. The CLAUDE.md file, placed at the root of the project, gives instructions shared across sessions. That's where you write what Claude can't guess.

In the project folder, run claude, then type /init. According to the documentation, Claude analyzes the project and generates a first CLAUDE.md with the commands and conventions it finds. You then add your own rules. Anthropic recommends staying under 200 lines: the longer the file, the less the instructions get followed.

Here's a short example, close to what I use:

# My app

## Stack

- Expo (SDK from create-expo-app), React Native, strict TypeScript
- Navigation: Expo Router, one file per screen in app/
- Data: Supabase (later), never a secret key in the app

## Rules

- One screen at a time. Don't touch files outside the request.
- No fixed heights in points: sizes relative to the screen,
  ScrollView if the content can overflow.
- Every screen handles 3 states: loading, empty, error.
- Interface text in French, with accents.
- Before coding more than 2 files: propose a plan and wait for my approval.

## Commands

- Run: npx expo start
- Tests: use the script actually present in package.json.
  If it doesn't exist yet, say so; don't report passing tests.
- Types: npx tsc --noEmit
- After every change: run the tests and the types, then tell me
  what changed and how to check it on iPhone.

The rule about fixed heights isn't there by accident. We'll get back to it in step 6.

Step 5: Prompt one screen at a time

"Build me a habit tracker app with a subscription" produces a huge, fragile project that's impossible to review. The method that works is the opposite: one request, one screen, one result you can test in five minutes.

Start with a plan

For anything that touches several files, switch to plan mode. Press Shift+Tab until you see plan mode on in the status bar. In this mode, Claude reads the files and proposes a plan, but changes nothing before you approve. You review, you correct, then you approve.

A first scoping prompt looks like this:

I want a habit tracker app. Version 1: a single feature,
checking off today's habits. Propose the list of screens and the
folder structure. Don't code anything yet.

Describe the screen, its states and its limits

Then, one prompt per screen. The more edge cases you name, the less Claude forgets them:

Create the app/index.tsx screen that lists today's habits.
- Each row: habit name, checkbox, current streak.
- Empty state: a text and an "Add a habit" button.
- Loading state and error state with a "Try again" button.
- Data comes from a local array for now.
- Must fit on an iPhone SE as well as on the largest iPhone:
  no fixed height, the list scrolls.
Run the tests and the types at the end.

Fix things without letting it rewrite everything

When a detail is off, stay precise and limit the scope:

On my iPhone, the "Add a habit" button slides under the bottom bar
when the list is long. Fix only this issue in app/index.tsx,
without touching the other files. Explain the cause.

You can also paste a screenshot into the terminal: Claude reads it.

Exercise: a habit that stays checked after relaunch

Here's a learning exercise to do in your own project, not a capture of a feature that already shipped. The goal is to go from a generated screen to a behavior you can verify. It requires no user account and no in-app purchase.

1. Keep a single local habit named "Read for 10 minutes".
2. Ask for a checkbox and local storage compatible with your Expo project.
3. Ask the agent to list the files changed, any dependency added and the commands actually run.
4. Install or open your app on the iPhone, then run the checks below.

Starting from the existing screen, make the "Read for 10 minutes" habit
checkable and keep its state after the app is closed and reopened.
Use the local storage compatible with the project's dependencies.
Don't create any account, server, subscription or extra statistics.
Before coding, explain how you'll handle loading and a failure
to read or save. Then make a limited change.
At the end: files changed, commands run, untested limits
and exact steps to check the result on iPhone.

Action on your iPhone	Expected result	If it fails
Open the app for the first time	The habit and its checkbox are visible, no error	Check the initial state and the storage loading
Check it, then close and reopen the app	The habit stays checked	Check the write, then the read, of the same key
Uncheck it, then relaunch	The habit stays unchecked	Make sure the false value is saved too
Repeat the flow in airplane mode	The local feature stays available	Look for a network dependency added for no reason
Increase the text size	The name and the control stay accessible	Remove the constraints that truncate or hide the action

Don't ask "rewrite everything" if one row fails. Describe the action, the expected result and the observed result. For example: "After relaunch, the box goes back to empty even though I had checked it. Explain the cause and fix the persistence without changing the design."

Download the CLAUDE.md template and the checklist (.md). Open it in your editor or in a notes app. Adapt the commands to your project before handing it to the agent.

Step 6: Get it reviewed and tested

Claude Code writes code that looks right. Only your tests and your iPhone tell you whether it is.

Tests so you don't break what works

The more your app grows, the more each request risks breaking a screen you already validated. The project created by Expo has no tests: first ask Claude to install Jest with jest-expo, as Expo's documentation recommends. Then ask for tests on the important logic (computing a streak, validating a form) and have them run after every change. That's why the test commands are written in CLAUDE.md: Claude runs them without you having to remind it. With a rules file and tests, the AI breaks what already worked much less often.

Review every change

You don't need to understand every line. You need to know which files changed, and why. If Claude touched an unrelated file, ask it why before accepting. Then ask: "what could break here?"

Check on a small and a large iPhone

This is the lesson that cost me the most. Solys was rejected by Apple under guideline 2.1: the onboarding demo was impossible to win on an iPad Air, where the app ran in iPhone compatibility mode. The cause: heights hardcoded in fixed points, not relative to the screen size. On my iPhone, everything was fine. The code had been reviewed, the tests were green. No tool had looked at the screen at another size.

Since then, I check every screen at least on the smallest iPhone and on the largest. If you only have one phone, the Xcode simulator on a Mac or a friend with a different model will do. Pay special attention to long text, the keyboard open on forms and buttons pinned to the bottom.

What Claude Code does badly

Claude Code excels at screens and logic. Outside your folder, it's much less reliable.

Signing and certificates

Without an authorized connection to your Apple account, Claude doesn't know its state. It can invent a certificate procedure that mixes up Xcode and Expo. Let EAS handle signing: Expo's documentation explains that EAS CLI can generate and store these files for you, once connected to your Apple Developer account.

App Store Connect

The listing, the privacy declarations, the screenshots and the legal links are data you need to check in App Store Connect. Claude Code can now act in a signed-in browser through its Chrome integration, with the necessary access. That doesn't guarantee the fields are correct: review the information, check which accounts are used and approve the commitments and the submission for review yourself.

Subscriptions

Writing a paywall takes ten minutes. Getting the App Store Connect products, their configuration in RevenueCat and the code to line up is another story. One identifier off by a single character and the paywall stays empty for the reviewer. The most common traps are listed in beginner iOS paywall mistakes.

Edge cases

Without instructions, Claude handles the happy path. No network, an empty list, an interrupted purchase: it's up to you to name them.

Supabase security

When Claude creates tables in Supabase, check that row-level security (RLS) is enabled, with policies that restrict each user to their own data. Also check that no secret key ends up in the app's code. Write these two prohibitions in your CLAUDE.md as soon as you connect a database.

Step 7: Move to TestFlight with EAS

Your screens have been checked in Expo Go or in a development build, depending on the modules used. Now move to the build that will be distributed to testers.

Set up EAS

You now need a paid Apple Developer account: as Expo points out, it's mandatory to send an app to the App Store. Then install Expo's tool and configure the project:

npm install --global eas-cli
eas login
eas build:configure

Add a unique bundle identifier in app.json, under ios.bundleIdentifier, for example com.tonnom.monapp.

Build and submit

eas build --platform ios --profile production
eas submit --platform ios

The first command compiles the app on Expo's servers. The first time, EAS offers to connect to your Apple account to create the certificates. The second sends the build to App Store Connect. You can also do it all at once with eas build --platform ios --auto-submit.

The build has to be processed by Apple before it shows up in TestFlight, and that processing can reject it, for example with ITMS-90717 for a transparent icon. So a successful upload doesn't mean it's installable yet: check its status in App Store Connect. Internal testers, external testers and beta review are explained in my guide TestFlight to test your iPhone app.

Redo the step 6 checks on this build. An app that works in Expo Go can still crash in production, for example when a native module is missing.

What it really costs

Here are the prices listed by the services, checked on September 27, 2026, in dollars. The amount you're billed also depends on your region, taxes and usage: check the plan before subscribing.

• Claude subscription: the Pro plan is $20 a month, or $17 a month billed annually. Max plans start at $100 a month, for more usage.
• Apple Developer account: $99 a year, mandatory for TestFlight and the App Store.
• EAS: Expo's free plan includes 15 iOS builds a month, in a low-priority queue. The Starter plan costs $19 a month, plus extra usage.

For a small prototype, Pro and EAS's free plan can be a starting point, if you stay within their quotas. Add the Apple account before TestFlight, then budget separately for the services you actually need: database, storage or a paid API. The first app budget template helps you lay out these items. You still need to plan for your own setup and verification time.

The honest limits, and where people get stuck

Claude Code changed who can build an iPhone app. It didn't change what Apple requires to publish it. A rejection comes quickly: Solys got some, so did Nolera and Clic. The most frequent reasons are covered in why Apple rejects an app.

You can get to TestFlight on your own with this tutorial. Where people get stuck most often is after that: wiring up subscriptions, preparing the file for the reviewer, understanding a rejection. For the big picture of the journey, read the page build an iPhone app.

For that part, the iOS Kit bundles the starter code from my apps, subscriptions included, the Claude Code skills for each step and the Apple Review Kit. The full path is on the page Claude Code training to build an iOS app.

Already stuck and not sure on what? The free diagnostic tells you what's really holding you back and sends you my checklist to avoid Apple rejections.

Frequently asked questions

Can you build an iPhone app with Claude Code without knowing how to code?

Yes for screens and simple logic, if you review and test each step. No if you're hoping to understand nothing at all. You need to be able to read an error message, run a command and check what Claude changed. You pick that up fast by building.

Is Claude Code free?

No. Claude Code requires a Pro, Max, Team, Enterprise or Console account. claude.ai's free plan doesn't include it. The Pro plan lets you get started, with usage limits to keep an eye on.

Do you need a Mac to build an iOS app with Claude Code?

No. You code on any computer, you test in Expo Go on your iPhone, and EAS compiles and submits the app on Expo's servers. A Mac is still handy for the simulator, but it's not required.

Claude Code or Cursor for a React Native app?

I use both, every day. Claude Code works in the terminal and chains changes and tests on its own. Cursor is an editor. The method matters more than the tool: rules, one screen at a time, tests.

How long does it take to publish a first app with Claude Code?

It depends on the size of the app and your time. A single-feature app goes much faster. The most unpredictable part is still Apple's review.

Can Claude Code set up in-app subscriptions?

It can write the paywall and RevenueCat code. With connected tools and the necessary permissions, it can also work in the consoles. Never assume the products are configured just because the code exists: check the identifiers, prices and entitlements after purchase, then test purchase and restore on TestFlight. The common iOS paywall mistakes give you the points to check.