How to Set Up Claude Code for iOS Development

Claude Code can write Swift and SwiftUI. It can scaffold views, wire up navigation, refactor data layers, and fix compiler errors. Out of the box, though, it can't build your Xcode project, see what's running in the simulator, or verify that the code it wrote actually produces the right UI. It operates blind.

The good news is that three MCP (Model Context Protocol) tools fill these gaps completely. Once configured, Claude Code can build your project, interact with the simulator, and run deterministic tests against your app, all without you switching windows. This guide walks through the full setup.

What You Need

Before you start, make sure you have Claude Code installed. You can install it globally with npm:

npm install -g @anthropic-ai/claude-code

Or via Homebrew:

brew install claude-code

You'll also need Xcode with iOS Simulator configured and working. Make sure you can build and run your project manually before bringing Claude Code into the picture. The agent will use the same build pipeline you already have, so any issues with schemes, signing, or simulator setup should be resolved first.

The three MCP tools you'll install are XcodeBuildMCP for building, ios-simulator-mcp for simulator interaction, and qckfx for test verification. Each one gives Claude Code a capability it lacks on its own, and together they form a complete development loop.

Step 1: Install XcodeBuildMCP

XcodeBuildMCP by Cameron Cooke gives Claude Code the ability to build your Xcode project, read build errors, manage simulators, and run the app. Without it, the agent can write code but has no way to compile it or see whether the build succeeded. With it, Claude Code can trigger a build, parse the output, and fix compiler errors on its own.

Installation instructions are in the XcodeBuildMCP repository. The setup involves adding the MCP server configuration to your Claude Code config file. Once installed, XcodeBuildMCP handles the entire build-run-debug cycle: building for simulator, installing the app, launching it, and capturing logs and build errors.

To verify it's working, open Claude Code in your project directory and ask it to “build the project”. You should see Claude Code invoke the XcodeBuildMCP tools, trigger an Xcode build, and report the result. If there are build errors, it will read them and attempt to fix them automatically.

Step 2: Install ios-simulator-mcp

ios-simulator-mcp by Joshua Yoes gives Claude Code direct control over the iOS Simulator. It can take screenshots, tap on elements, swipe, type text, and describe the accessibility tree. This is what lets the agent actually see and interact with the running app rather than just writing code and hoping it works.

Setup instructions are in the ios-simulator-mcp repository. Like XcodeBuildMCP, you add the server to your Claude Code MCP configuration. The two tools work well together: XcodeBuildMCP handles the build pipeline, and ios-simulator-mcp handles fine-grained interaction with the running app.

To verify it's working, build and launch your app in the simulator, then ask Claude Code to “take a screenshot of the simulator”. You should see the agent capture a screenshot and describe what's on screen. If it can see the app, the tool is configured correctly.

Step 3: Install qckfx

qckfx gives Claude Code the ability to run deterministic tests against your app. Where ios-simulator-mcp lets the agent take screenshots and interpret them (which is slow and unreliable), qckfx provides a different approach: you record a test flow by using your app in the simulator, and then anyone (you or your agent) can replay that test at any time and see exactly what changed. Network responses are recorded and replayed, so tests produce the same result every run. The agent gets a clear pass/fail with visual diffs showing precisely what's different.

Install qckfx via Homebrew:

brew install qckfx/tap/qckfx

Or download directly:

After installing, launch qckfx. You'll see a menu bar icon. Click it and select Install MCP Server, then pick Claude Code from the list. This configures the MCP server automatically alongside any other MCP servers you already have, like XcodeBuildMCP or ios-simulator-mcp. No manual config editing required.

To create your first test, open your app in the simulator and start a recording session from the qckfx menu bar. Then use the app as you normally would: tap through a flow, scroll a list, fill out a form. qckfx captures every interaction and every network response. When you stop recording, that session becomes a replayable test with a visual baseline of every screen.

To verify it's working, ask Claude Code to “run the tests”. The agent will invoke qckfx, replay your recorded flows, and report back with pass/fail results. If every screen matches the baseline, the tests pass. If something looks different, qckfx shows a visual diff of exactly what changed, along with logs and a network request timeline.

The Development Loop

With all three tools installed, Claude Code has everything it needs to operate autonomously on your iOS project. The workflow looks like this: you ask Claude Code to make a change (add a button, redesign a screen, fix a bug), and it writes the Swift or SwiftUI code. Then it builds the project using XcodeBuildMCP. If there are compile errors, it reads them and fixes them. Once the build succeeds, it runs your qckfx tests to verify that the change looks correct and that nothing else broke.

If the tests pass, the agent reports success and moves on. If a test fails, the agent gets a visual diff showing the exact screens that changed, console logs from the test run, and a timeline of network requests highlighting any anomalies. With that information, it can diagnose the issue and iterate without you stepping in.

This is the complete build-run-verify loop, all driven by the agent. The agent writes code, confirms it compiles, and confirms it produces the correct output. You stay in the conversation, reviewing what the agent did and steering its direction, rather than manually checking every screen in the simulator after every change.

The loop also works well for larger refactors. If you ask Claude Code to restructure a navigation stack or replace a networking layer, it can build after each step, run the full test suite, and catch regressions as they happen rather than at the end when the cause is harder to trace.

Tips for Getting the Most Out of Claude Code on iOS

Record baseline tests before starting agent-driven changes

Before you ask Claude Code to modify anything, record qckfx test flows for your key screens and user journeys. A login flow, the main list view, a detail screen, a settings page. These baselines give the agent something to verify against. Without them, the agent can build and run the app, but it has no way to confirm the UI is correct other than taking screenshots and guessing.

Recording is fast. Open the app in the simulator, start a recording, tap through the flow, stop the recording. A five-screen flow takes about thirty seconds. That thirty-second investment saves you from manually verifying every change the agent makes.

Use CLAUDE.md to describe your project

Claude Code reads a CLAUDE.md file from your project root for context about your codebase. For iOS projects, this is especially valuable. Tell Claude Code which scheme to build, what simulator to target, where your views live, and any architectural patterns you follow (MVVM, TCA, etc.). The more context you provide, the fewer wrong turns the agent takes.

A good CLAUDE.md for an iOS project might include the build scheme name, the simulator device and OS version, the directory structure (where views, models, and networking code live), and any conventions like “all new views should use the DesignSystem color tokens.” This file acts as a persistent briefing that the agent reads at the start of every session.

Verify after each significant change

Ask the agent to run tests after each meaningful modification, not just at the end. If you ask Claude Code to add three features in a row without verifying in between, and the third one breaks something, the agent has to debug three changes worth of code instead of one. Verifying after each step keeps the feedback loop tight and makes failures easy to trace.

You can make this the default behavior by adding a note to your CLAUDE.md like “after making UI changes, build the project and run the qckfx tests before moving on.” The agent will follow this instruction on every task, giving you a build-run-verify cycle on every change without you having to ask each time.

Conclusion

Claude Code is capable of writing solid Swift and SwiftUI. The gap has always been in the tooling around it: building, running, and verifying. XcodeBuildMCP gives it the ability to build. ios-simulator-mcp gives it the ability to see and interact with the simulator. qckfx gives it the ability to verify its work deterministically, with recorded test flows that replay the same way every time.

Together, these three tools turn Claude Code from a code writer into a full iOS development agent. It can make changes, confirm they compile, and confirm they produce the right output. That complete loop is what makes agent-driven iOS development practical.

qckfx is free and runs locally on your Mac. qckfx.com