How to Set Up Claude Code for iOS Development With Xcode and Simulator

From your Mac’s terminal, Claude Code can inspect and edit an iOS project, then use Apple’s tools to build and test its code. Xcode remains responsible for compiling the app and providing the iOS Simulator, Apple’s software environment for running an iOS app on a Mac. A successful command-line build confirms that Xcode completed the requested build; it does not confirm that the app looks or behaves correctly on screen.

To make these steps repeatable, install Claude Code and the full Xcode app. Find your project’s scheme and an available simulator. Check Xcode’s instructions for what to build and how to run or test it. Tell Claude Code when to build and test, and to ask before changing project settings. Afterward, check the app in Simulator and review Claude Code’s changes.

Install Claude Code and Xcode

Install Claude Code using Anthropic’s current setup instructions. The instructions cover installation options and account access. After installation, check the command and its configuration:

claude --version
claude doctor

Install the full Xcode app as well. Apple’s separate Command Line Tools package does not include all the tools used in this workflow, including xcodebuild for building and testing Xcode projects. Xcode also provides simctl, the command-line tool for controlling Simulator. Apple describes the distinction in its documentation on installing command-line tools.

Check which Xcode installation your Mac has selected and whether its tools and simulator devices are available:

xcode-select -p
xcodebuild -version
xcrun simctl list devices available

If your Mac has multiple Xcode installations, select the one you intend to use. For example:

sudo xcode-select -s /Applications/Xcode.app/Contents/Developer

For a first-time setup, Apple’s Xcode component instructions include running the first-launch setup and downloading an iOS platform runtime:

xcodebuild -runFirstLaunch
xcodebuild -downloadPlatform iOS

Simulator runtimes are separate from the command-line tools. If the device list does not show an iOS simulator you need, use Xcode’s Components settings or the documented command to install a runtime supported by your Xcode version. The available simulator models and operating-system versions depend on that installation.

Identify the project and simulator

Open a terminal from the iOS project directory before you start Claude Code. An Xcode project usually has a .xcodeproj file. A workspace, which can group multiple projects, uses an .xcworkspace file. The scheme is Xcode’s set of instructions for what to build and how to run or test it.

Ask Xcode to list the schemes for your project or workspace:

xcodebuild -list -project MyApp.xcodeproj

For a workspace, use:

xcodebuild -list -workspace MyApp.xcworkspace

Replace the example filename with the one in your project. Then inspect the simulator devices Xcode can use:

xcrun simctl list devices available

Use a scheme and destination shown by your own Xcode installation. Device names in examples are not universal. Apple’s Xcode command-line reference points to the installed tool’s help and manual pages for command options.

Build and test with xcodebuild

Use xcodebuild to run a build from the terminal. Specify the project or workspace, the scheme, and a Simulator destination. The destination tells Xcode which simulated device and iOS software environment, called a runtime, to use.

xcodebuild \
  -project MyApp.xcodeproj \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=YOUR_SIMULATOR_NAME' \
  -derivedDataPath build/DerivedData \
  build

Replace MyApp.xcodeproj, MyApp, and YOUR_SIMULATOR_NAME with values from your project and device list. If you use a workspace, replace the -project option and filename with -workspace MyApp.xcworkspace.

Run the scheme’s tests against the same destination:

xcodebuild \
  -project MyApp.xcodeproj \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=YOUR_SIMULATOR_NAME' \
  -derivedDataPath build/DerivedData \
  -resultBundlePath build/TestResults.xcresult \
  test

A test run saves its results in an .xcresult bundle at the path you specify. Apple’s testing documentation explains how Xcode stores test results and logs. If a command fails, check the error output and your scheme, destination, and project path before asking Claude Code to change source code. Consult xcodebuild -help for options supported by your installed Xcode version.

Launch the app in Simulator

A completed build does not show whether the app’s interface works as intended. Start Simulator and choose the device you want to inspect:

open -a Simulator
xcrun simctl list devices available

You can also use simctl to boot a device, install the built .app, and launch it using its bundle identifier, the identifier Xcode assigns to the app. Your project settings determine where Xcode puts the built .app and what bundle identifier it uses. Check those values in your project, then consult the installed tool’s commands before running them:

xcrun simctl help
xcrun simctl help boot
xcrun simctl help install
xcrun simctl help launch

Once the app is running, interact with it in Simulator and check the screens or behavior affected by your change. Apple explains how to run apps on simulated or physical devices. Simulator does not reproduce every hardware feature or physical-device performance characteristic, so test on a physical device when the feature depends on actual hardware or requires real-device validation.

Give Claude Code a verifiable task

From the project directory, start an interactive Claude Code session:

claude

Ask Claude Code to inspect the project before editing. For example:

Inspect this Xcode project and identify its project or workspace file, app scheme, and an available iOS Simulator destination. Before editing, tell me what you plan to change. After the change, run the matching xcodebuild build and relevant tests. Report the exact commands and results, and state separately whether you launched the app in Simulator and visually checked it. Ask before changing signing settings, entitlements, project configuration, or dependencies.

A scheme names what Xcode builds; signing settings and entitlements control how an app is authorized and what protected capabilities it can use. Asking before Claude Code changes those settings helps you review project-level changes that affect more than the edited source file. Keep Claude Code’s normal permission prompts enabled when you are getting familiar with a project. Anthropic documents the available CLI permission controls; skipping prompts is a separate option, not a required part of this setup.

Keep the project’s canonical build and test commands in its README or another project note. That gives you and Claude Code a reliable reference for the correct scheme, project or workspace, and simulator destination. Review the source-code diff, which shows the changes, and any project-file changes yourself. A passing build or test run does not establish that you visually checked the app.

What I'm building

Delegate tasks. Get software.

Give Vroni a GitHub issue, bug report, spec, or rough idea. It reads the repo, plans the change, writes code, runs checks, and works toward a review-ready pull request.

Take a look at vroni.com