# iOS app with AI

> Cursor handles Swift / SwiftUI better than the terminal-first agents because most iOS work involves visual layout and the codegen needs to see selection state. Xcode does what only Xcode can: simulators, signing, profiling, App Store Connect. Claude (chat) is where you decide what to build before either tool starts editing.

Source: https://aistack.sh/stack/ios-app-with-ai
Category: Code · Mobile
Level: Intermediate
Last verified by a human: 2026-05-05

## The tools

### Claude — Product + plan

- Pricing: Free · $20/mo Pro · $100/mo Max 5x · $200/mo Max 20x · Sonnet API $2/$10 per M tokens (input/output)
- Site: https://claude.ai
- Why this one: Before you open Xcode, decide what you're building. Claude is the chat surface for the design/info-architecture/data-model conversation. Especially valuable on iOS where over-scoping is costly (every screen needs design polish to look native).
- Swap in instead: ChatGPT, Gemini
- More: https://aistack.sh/tool/claude

### Cursor — Swift / SwiftUI editing

- Pricing: Free Hobby · $20/mo Pro · $60/mo Pro+ · $200/mo Ultra · $40/seat Teams · $120/seat Teams Premium
- Site: https://cursor.com
- Why this one: Inline AI completions for Swift, Composer for multi-file changes, and decent SwiftUI preview integration. Cursor's hold on Swift code quality has improved a lot — better than copy-pasting into a chat tab, comparable to Claude Code for typical iOS work.
- Swap in instead: Claude Code, Codex
- More: https://aistack.sh/tool/cursor

### Xcode — Build, sign, run, ship

- Pricing: Free · Apple Developer Program $99/year for App Store
- Site: https://developer.apple.com/xcode/
- Why this one: Where the app actually compiles and runs. Required for Simulator, Instruments (profiling), Signing & Capabilities, and App Store Connect distribution. AI agents drive Cursor; you drive Xcode.
- More: https://aistack.sh/tool/xcode

## Monthly cost

### $28/mo — Solo, 1 indie app (small)

- Claude: Free tier
- Cursor: $20
- Xcode: Free
- + developer-program: $8 (annualized)

### $48/mo — Solo, multiple apps + ads (medium)

- Claude: $20
- Cursor: $20
- Xcode: Free
- + developer-program: $8

### $220/mo — Small team, 3 to 5 devs (heavy)

- Claude: $20
- Cursor: $200 (5x $40 Business)
- Xcode: Free
- + developer-program: $0 (org-wide)

## Workflow

### 1. Sketch the app in Claude (Claude)

Before any code: scope the screens, the data model, the privacy story (everything Apple cares about during review).

**Prompt: iOS app scoping prompt**

```
Plan a small, well-scoped iOS app for the idea below. Don't write Swift code yet.

Idea:
"""
{{1-line product description}}
"""

Constraints:
- Solo developer, weekend MVP, then iterate.
- Native iOS only (SwiftUI). No cross-platform unless I push back.
- Local-only data unless I ask for sync (privacy + review speed).
- No 3rd-party SDKs that block App Store review (no obscure analytics, no SDKs that violate ATT).

Output, in this order:
1. **Screens** (3 to 6 max for MVP) — name + 1-line purpose.
2. **Data model** — Swift types or SwiftData / Core Data schema, whichever is simpler.
3. **Permissions / capabilities** — exactly what entitlements you need and the App Store review reasons.
4. **App Store hooks** — name candidates (3), category, the 1-line subtitle, the "what's the screenshot story".
5. **Out of scope for v1** — 3 to 5 features I should NOT build before launch.

Push back if the idea has obvious App Store rejection risks.
```

### 2. Scaffold in Cursor (Cursor)

Open Cursor at the project root. Use Composer (agent mode) to scaffold the screens from step 1. Don't accept the whole diff at once — go screen-by-screen so SwiftUI previews stay healthy.

**Prompt: Scaffold a SwiftUI screen**

```
Build a SwiftUI screen for {{screen_name}} from the plan we agreed on.

Constraints:
- SwiftUI only. No UIKit unless I explicitly ask.
- Use the {{e.g. SwiftData / Core Data / @Observable}} pattern already in this project.
- Match the existing folder structure (look at @Views and @Models before adding files).
- No new dependencies. No SwiftPM additions in this turn.
- Add a #Preview at the bottom that runs without any external state.

Output: the new file(s) with a 2-line summary of what was added, ready for me to accept hunk-by-hunk.
```

### 3. Run in the Simulator (Xcode)

Cmd-R in Xcode. Cursor's preview is fast; Xcode's Simulator is the truth. If the layout breaks at smaller sizes (SE) or with Dynamic Type at the largest setting, fix before moving on — App Review reads accessibility.

### 4. Sign + archive + upload (Xcode)

Xcode → Product → Archive → Distribute App → App Store Connect. Once: set up automatic signing in Signing & Capabilities. TestFlight build is ready in ~10 min.

### 5. Submit for review (Claude)

Use Claude to draft the App Store description, the privacy nutrition label answers, and the review-notes message. App Store rejections are usually metadata or privacy issues, not code.

## What it produced

**Indie dev, 2 apps shipped in a quarter**

Both apps built solo. Cursor handled ~80% of the SwiftUI; the dev wrote Xcode signing config + the privacy label by hand. Both apps cleared App Review on the first submission, mostly because the privacy story was scoped tight from the Claude planning step.

## Pitfalls

- **AI-generated UIKit when SwiftUI was simpler** — Cursor's first instinct is occasionally to drop into UIKit for things SwiftUI can do natively. Reject and re-prompt; mixing UIKit and SwiftUI early adds 2x the maintenance cost.
- **Skipping the privacy nutrition label** — Apple rejects more apps for privacy-label mismatches than for actual bugs. Use Claude to walk through every framework you import and what data it touches — get the answers right before submitting.
- **Treating the Xcode UI as optional** — Some terminal-only devs try to build with `xcodebuild` and skip Xcode. You can — but you'll fight signing, capabilities, and App Store Connect issues that the GUI surfaces clearly. Use Xcode for the deploy lane even if your editor is Cursor.

## Recent changes affecting this stack

- **Cursor launches Projects to coordinate large bodies of work with subagent delegation** (2026-09-10, feature) — Projects enables managing feature development, migrations, and full apps with a coordinator agent that plans work, delegates to subagents, and maintains context over months. The coordinator runs agents in parallel and can watch Slack channels or run on schedules to automatically pick up work without explicit prompting. Source: https://cursor.com/changelog
- **Cursor launches Projects for coordinating multi-month work across thousands of subagents** (2026-09-10, feature) — Projects maintain context over months of work, with a coordinator agent that plans work and delegates to subagents running in parallel. Projects can watch Slack channels or run on schedules to take action without being prompted, keeping shared context across all agents involved. Source: https://cursor.com/changelog
- **Cursor launches Projects for coordinating large bodies of work with multiple subagents** (2026-09-10, feature) — Projects is a new feature that maintains context over months of work and delegates tasks to thousands of subagents. A coordinator agent plans the work and delegates to implementation agents that run in parallel. Projects can watch Slack channels, follow PRs, or run on a schedule to take action automatically without prompting. Source: https://cursor.com/changelog
- **Cursor adds self-hosted machine support with dynamic pool scheduling and computer use** (2026-09-02, feature) — Cloud agents can now execute on internal infrastructure, keeping codebases and secrets on-premise. Features include dynamic pool scaling that grows with demand and hibernates idle workers, plus computer use (clicks, typing, screenshots) on Linux and Mac self-hosted workers. Source: https://cursor.com/changelog
- **Cursor adds self-hosted machines with dynamic pool scheduling and multi-platform computer use** (2026-09-02, feature) — Cursor now supports self-hosted machines that keep tool execution entirely in your infrastructure. Features include dynamic pool scheduling for teams with auto-scaling capacity, execution on existing platforms (AWS Lambda, Coder, Cloudflare, Modal, etc.), and computer use support on Linux and Mac for browser automation and desktop interaction. Source: https://cursor.com/changelog

---

Curated by alex-w on aistack.sh. Last updated 2026-05-05.