A practical, production-ready walkthrough for developers and non-coders alike: from zero to App Store.
You have an idea for an iOS app. You've heard Claude Code can write the whole thing for you. You Google "how to build an iOS app" and five minutes later you're reading about Swift, Xcode, provisioning profiles, and signing certificates, and you close the laptop.
Here's the thing: you don't have to go near Xcode. There is a modern, AI-friendly stack that lets Claude Code do the heavy lifting while you stay firmly in the driving seat. This guide walks you through exactly that, from the first prompt all the way to a live app on the App Store, and then goes one level deeper into the backend infrastructure that most tutorials completely ignore.
Why the "Install Xcode" Advice Is Wrong for Non-Coders
Almost every iOS tutorial starts with "Step 1: Download Xcode." Xcode is Apple's official IDE, and it weighs in at roughly 15 GB. It is a deeply professional tool built for engineers who speak Swift fluently, understand Interface Builder, and have memorised the difference between a simulator scheme and an archive build. For a non-coder using an AI assistant, Xcode is a trap. The moment something breaks inside it (and it will) you are staring at cryptic build logs in a language Claude cannot fully see, because Claude Code operates in your terminal, not inside a proprietary GUI.
Beyond the learning curve, Xcode tethers you to a macOS machine. No Mac? No build. Xcode also introduces a layer of abstraction between Claude's generated code and the running app that is genuinely hostile to the "write → see → iterate" loop that makes AI-assisted development so powerful.
The good news: the open-source ecosystem has largely solved this problem. The approach below replaces Xcode with a cloud-first toolchain that runs entirely from your terminal and your phone's camera.
The Stack: What Claude Code Will Actually Use
| Tool | What It Replaces | Why It Works with Claude Code |
|---|---|---|
| Expo | Xcode + Swift boilerplate | Zero-config React Native scaffold; Claude knows it cold |
| Expo Go | iOS Simulator | Runs on your real phone via QR code, no Apple Developer account needed for testing |
| NativeWind | UIKit / SwiftUI styling | Tailwind CSS syntax for mobile; Claude's training data is saturated with Tailwind |
| EAS Build | Xcode Archive & Organizer | Cloud build service; submits to App Store without touching your machine |
| Supabase / PostgreSQL on VPS | Firebase / managed backend | Portable, cost-efficient, and vendor-lock-free (more on this below) |
This table alone should reframe your mental model. You are not building a "Swift app." You are building a React Native app delivered as a native iOS binary, using a toolchain that Claude Code was effectively trained to generate.
Step-by-Step: Building Your iOS App with Claude Code
1. Bootstrap with Expo — Skip Xcode Entirely
Open your terminal, open Claude Code, and give it this instruction:
"Create a new Expo app using
create-expo-app. Use TypeScript. Set up the folder structure for a [your app idea] with a tab-based navigation using Expo Router."
Claude Code will run the scaffolding commands, install dependencies, and produce a working project. You do not install Xcode. You do not write a single line of Swift. The entire app is written in TypeScript/React Native, which compiles to native iOS code only at build time — and that build happens in the cloud.
This approach aligns with what researchers studying AI-assisted software development at Microsoft Research found: AI coding assistants are most effective when the human operator focuses on intent specification (what the app should do) rather than syntax supervision (how the code is written). The productivity gains compound fastest in domains — like React Native — where the AI's training corpus is densest. (Copilot Productivity Study, GitHub/Microsoft, 2023)
2. Test Instantly with Expo Go
Once Claude Code has the project running (npx expo start), it will display a QR code in your terminal. Download Expo Go from the App Store on your iPhone, scan the code, and your app is running on your actual device — with live reload. Every time Claude edits a file, the phone updates in seconds.
This loop is the single biggest unlock for non-coders using AI. You are not waiting for builds. You are not interpreting simulator errors. You see the app on glass in your hand, you describe what looks wrong to Claude, and it fixes it.
3. Style with NativeWind — Because Claude Already Knows Tailwind
Tell Claude Code:
"Install NativeWind and configure it. Use Tailwind utility classes for all component styling going forward."
NativeWind translates Tailwind CSS class names into React Native StyleSheet objects at compile time. The reason this matters for AI-assisted development is statistical: Tailwind is one of the most documented CSS frameworks on the internet. Claude's ability to produce correct, aesthetically coherent Tailwind classes is dramatically higher than its ability to produce correct React Native StyleSheet objects from scratch. The result is that your UI actually looks good — not like a default component dump.
This is supported by survey data from Stack Overflow's 2024 Developer Survey, which found Tailwind CSS to be the most-used CSS framework for the third consecutive year, with 52% adoption among professional web developers — ensuring robust AI training coverage. (Stack Overflow Developer Survey 2024)
4. Ship to the App Store with EAS Build
When you are ready to publish, tell Claude Code:
"Configure EAS Build for this project. Set up an
eas.jsonwith production and preview profiles. Walk me through submitting to the App Store."
EAS Build (Expo Application Services) compiles your React Native code into a native .ipa file on Expo's cloud infrastructure. You never run xcodebuild. You never sign a certificate manually. You upload the binary to App Store Connect through the EAS CLI or Expo's dashboard.
The practical implication: you can ship an iOS app from a Windows laptop or a Linux machine. The only Apple requirement is a paid Apple Developer Program membership ($99/year), which you need regardless of your toolchain.
The Safety Checklist Every iOS Developer Should Follow
Before you ship anything, this checklist from developer and security advocate @prajwaltomar_ captures the critical pre-launch verification steps cleanly:
The Backend Problem: What AI-Generated Code Gets Wrong
Building the front end is only half the job. Most iOS apps need a backend — an API, a database, authentication, file storage. Claude Code will generate all of this for you, typically as a Node.js or Python API paired with a PostgreSQL database, containerised with Docker.
The generated code will run. What it will not do, by default, is survive production. This is the gap that costs developers money, data, and App Store reviews.
Choosing Your Infrastructure: VPS Over Managed Cloud
Before we get into hardening, there is an architectural decision worth making consciously. The default recommendation from most tutorials is to deploy to a managed platform — Heroku, Railway, Render, or Firebase. These are convenient, but they impose vendor-specific abstractions that make migration expensive and painful.
David Heinemeier Hansson, creator of Ruby on Rails and CTO of 37signals, has been vocal on this:
We can't have competition in the cloud as long as folks are locked into proprietary or overly-complicated setups that makes moving from one vendor to another a huge hassle and expense... [Containerization] allows you to move through all those stages of a production deployment without onerous migration costs.
This is the strongest argument for pairing Claude Code's Docker output with a straightforward VPS. When Claude Code generates your Dockerized backend, it isn't just saving you development time — it is buying you architectural freedom. You own the containers. If your app scales overnight, you are not trapped paying exorbitant managed-cloud fees; you rent a larger server and move your containers in minutes. Providers like HostZealot offer bare-metal and VPS tiers specifically sized for this kind of portable, container-native deployment.
The "Day-Two" Infrastructure Blind Spots
To understand exactly what Claude Code misses on infrastructure, I asked Mike Kharchenko, a hosting expert at HostZealot with more than seven years of experience powering iOS app backends, the following question:
"When an iOS developer uses an AI like Claude Code to generate and deploy a Dockerized API and PostgreSQL stack on a raw VPS, what critical 'day-two' production blind spots does the AI typically miss, and how should they configure their HostZealot server to prevent these catastrophic failures?"
The gap between "code that runs" and "infrastructure that survives" is where most AI-generated backends collapse in production. Three areas are almost always neglected.
First, security and Apple ATS compliance. AI-generated docker-compose files notoriously expose database ports globally — port 5432 open to the world. You need internal Docker networks so your API and Postgres talk to each other privately, a UFW ruleset that blocks everything except 80, 443, and your SSH port, and a reverse proxy like Nginx or Traefik terminating SSL with a Let's Encrypt certificate. This last point is not optional: Apple's App Transport Security policy enforces HTTPS for all network connections, so an app talking to a plain HTTP endpoint will be rejected at the App Store review stage.
Second, data persistence and disaster recovery. Docker volumes mapped incorrectly mean your database is ephemeral — a container restart and your production data is gone. Map your Postgres data directory to a host path explicitly, then set up a cron job that runs pg_dump, compresses the output, and ships it to an offsite S3-compatible bucket nightly. HostZealot's VPS plans include a separate backup volume you can mount specifically for this.
Third, resource allocation. Node.js and Python APIs can spike memory during traffic bursts. Without Docker memory limits set in your compose file, a spike in your API tier can exhaust RAM and trigger the Linux OOM killer against your Postgres process — which is exactly backwards from what you want. Set explicit memory limits per service, configure swap space on the host (at least 2x the physical RAM for a small VPS), and use a process monitor to alert you before the machine hits the ceiling.
The AI gives you the skeleton. These three layers are what make it production-grade.
Production Infrastructure Checklist
The following table summarises the hardening steps Mike describes, mapped to the specific Docker and server configuration changes required:
| Risk Area | AI-Generated Default | Production Configuration |
|---|---|---|
| Database port exposure |
ports: "5432:5432" in compose |
Internal Docker network only; no host port mapping |
| SSL / HTTPS | None | Nginx reverse proxy + Let's Encrypt (Certbot) |
| Firewall | Open | UFW: allow 22, 80, 443; deny all else |
| Data persistence | Anonymous volume | Named volume mapped to host path (/data/postgres) |
| Backup | None | Nightly pg_dump → compressed → offsite S3 bucket |
| Memory limits | None |
mem_limit: 512m per service in compose file |
| Swap space | OS default (often 0) | 2–4 GB swap configured on host |
| ATS compliance | HTTP API | HTTPS with valid certificate (required by Apple) |
Mobile App Market Context: Why This Stack Is Timely
React Native's share of cross-platform mobile development has grown consistently since 2019, making it the dominant framework for teams that want a single codebase targeting both iOS and Android. Expo, which wraps React Native with managed tooling, has accelerated this trend by eliminating the native build environment requirement — exactly the friction this guide sidesteps.
The adoption of AI coding assistants among professional developers crossed 60% in 2024, with the fastest growth in mobile and full-stack categories. Claude Code specifically has seen rapid uptake for scaffolding tasks — generating project boilerplates, writing API route handlers, and producing Docker configuration files — precisely the tasks this guide delegates to it.
Research from the ACM examining AI pair programming in mobile contexts found that developers using LLM assistants completed feature implementation tasks 35–55% faster than control groups, with the largest gains in boilerplate-heavy environments like React Native configuration. (ACM Digital Library — AI-Assisted Mobile Development, 2023)
A separate analysis from the MIT Sloan School of Management on software productivity and AI tooling concluded that the quality delta between AI-assisted and unassisted code is largest in well-documented, high-frequency domains — again strongly favouring React Native and Expo over lower-coverage targets like native Swift. (MIT Sloan Working Paper on AI and Developer Productivity, 2024)
Going Deeper: Recommended Reading
If this guide has sparked questions about adjacent topics, the following articles from the developer community go further:
Building a Full-Stack App with Expo Router and Supabase — A hands-on walkthrough pairing the Expo Router file-based navigation system with a Supabase backend, which maps cleanly onto the stack described in this guide.
NativeWind v4: Tailwind CSS for React Native in 2024 — A deep dive into the NativeWind configuration changes in v4 and how to handle edge cases that Claude Code may generate incorrectly on the first pass.
Dockerizing a Node.js API for Production: Beyond the Basics — Covers multi-stage Docker builds, non-root user containers, and health checks — all things Claude Code omits from its generated
Dockerfileby default.
The Mental Model That Ties It Together
Claude Code is extraordinarily good at generation. It is structurally weak at operational awareness — the things that don't show up until a server has been running for 72 hours and the swap is full. The workflow this guide describes exploits the first capability while delegating the second to proven tooling and expert configuration.
On the front end, Expo + NativeWind + EAS Build give you a shipping path to the App Store that requires zero knowledge of Xcode, Swift, or Apple's build toolchain. Claude Code handles the code; Expo's cloud handles the compilation; your phone handles the testing.
On the backend, Claude Code generates solid Docker scaffolding that is production-adjacent. Making it genuinely production-ready requires the four layers Mike Kharchenko describes — network isolation, TLS termination, persistence mapping, and resource limits — applied to a reliable VPS where you control the environment.
The architectural result is an app stack that is portable, cost-efficient, and free from the vendor lock-in that DHH has spent years arguing against. You own the containers. You own the data. If you outgrow your server, you move in an afternoon.
That is the stack. Build something.
Further reading on the regulatory and technical landscape for iOS apps: Apple App Store Review Guidelines and the WWDC 2023 session on App Transport Security.
Top comments (0)