Chris Wood
Founder, qckfx
MCP (Model Context Protocol) is the standard way for AI coding agents to interact with external tools. If you're using Claude Code, Cursor, or Codex, MCP is how your agent reaches beyond editing files and into the real world of building, running, and testing your app.
For iOS developers, this changes the game. Your agent can compile your project, launch it in the simulator, and verify that the UI looks correct. All without you copying build logs or manually checking screens. But the experience depends entirely on which MCP tools you have installed. Here are the three that matter.
XcodeBuildMCP
XcodeBuildMCP gives your agent the ability to build and manage Xcode projects. It exposes tools for compiling your app, reading build errors, listing schemes and targets, and resolving Swift package dependencies. When your agent writes code and needs to check if it compiles, it calls XcodeBuildMCP instead of asking you to open Xcode and read back the error messages.
This is foundational because compilation is the first feedback loop in iOS development. Without XcodeBuildMCP, your agent writes code blind. It can make changes that look correct syntactically but fail to compile because of a missing import, a type mismatch, or an API that changed in a newer SDK. With XcodeBuildMCP, the agent builds the project, reads the diagnostics, and iterates on the fix. That loop happens in seconds, entirely within the agent's workflow.
XcodeBuildMCP also handles the project management side of things. Agents can list available schemes, resolve packages, and clean build artifacts. This is especially useful when the agent is working on a project for the first time and needs to understand the build configuration before making changes.
ios-simulator-mcp
ios-simulator-mcp lets your agent control the iOS Simulator directly. It can boot simulators, install and launch apps, take screenshots, and perform touch interactions like tapping and scrolling. Once your agent has built the app with XcodeBuildMCP, ios-simulator-mcp is how it actually runs the app and sees what's on screen.
The ability to take screenshots and interact with the running app gives your agent a visual understanding of your UI. It can tap a button, scroll through a list, navigate between screens, and capture what it sees at each step. For basic exploration and quick checks, this is valuable. Your agent can build a new feature, launch the app, and take a screenshot to see if the layout looks reasonable.
There is an important limitation to keep in mind. Screenshots alone don't provide reliable verification. Your agent can see what's on screen, but it has no reference for what the screen should look like. It can't tell if a button shifted 10 pixels after a refactor, or if a font size changed subtly, or if a view that used to be visible is now partially clipped. As covered in Giving Your Agent Eyes is not Enough, verification requires comparison against a known-good state. Without that baseline, the agent is guessing.
That said, ios-simulator-mcp is essential for the interactive parts of development. Agents need to install apps, navigate flows, and occasionally inspect the UI during development. It fills a critical role in the toolchain, even if it can't solve verification on its own.
qckfx
qckfx is a record-and-replay regression testing tool for iOS. You record a test by using your app in the simulator. Tap through a flow, scroll through content, trigger network requests. qckfx captures everything: touch events, screenshots at each step, network responses, disk state, and keychain data. That recording becomes your baseline. From that point on, you or your agent can replay the test at any time and get deterministic results with visual diffs showing exactly what changed.
This is the tool that closes the verification gap. When your agent runs a qckfx test, it gets back a definitive pass or fail. If something changed, it receives visual diff images highlighting every pixel that's different between the baseline and the current run. It also gets access to console logs from the test run and a timeline of network requests, with anomalies flagged automatically. This gives the agent enough context to understand not just that something broke, but why.
Because qckfx replays recorded network responses, tests never flake due to slow APIs, changed server data, or network timeouts. Scroll positions are replayed exactly. Simulator state is restored to match the recording. The result is a test that runs the same way every time, which is exactly what agents need. Flaky tests waste tokens and confuse agents into trying to fix code that was never broken.
qckfx is free and runs entirely on your Mac. There's no SDK to integrate, no test code to write, and no cloud service to configure. You record your existing manual testing workflows and they become automated regression tests.
Putting It All Together
These three tools form a complete iOS agent stack. XcodeBuildMCP handles the build. ios-simulator-mcp handles interaction. qckfx handles verification. Each tool owns one part of the development loop, and together they let your agent operate the way you do: write code, build it, run it, check that it works, and iterate if something is wrong.
Here's what the workflow looks like in practice. Your agent makes a code change, then calls XcodeBuildMCP to compile the project. If the build fails, it reads the diagnostics and fixes the issue. Once the build succeeds, ios-simulator-mcp installs and launches the app. Then qckfx replays your recorded tests against the new build. If every test passes, the agent knows its changes are safe. If a test fails, the agent gets visual diffs, logs, and network timelines that tell it exactly what went wrong. It can then make a targeted fix and run the loop again.
This loop is fast because there's no AI in the loop during test execution. The agent kicks off a qckfx test, waits for the result, and then uses one inference call to reason about the output. Compare that to an agent driving the simulator step by step, where every tap and every screenshot requires a separate LLM call. The record-and-replay approach is faster, cheaper, and more reliable.
Each tool can also be used independently. XcodeBuildMCP is useful even without the other two, because build errors are the most common feedback an agent needs. ios-simulator-mcp is helpful for ad-hoc exploration. And qckfx works as a standalone testing tool whether or not you're using agents at all. But the combination of all three is where you get the full benefit.
How to Install These
XcodeBuildMCP
Install via Homebrew and add it to your MCP configuration:
brew install xcodebuildmcpThen add the server to your MCP config (for Claude Code, that's .mcp.json in your project root):
{
"mcpServers": {
"XcodeBuildMCP": {
"command": "xcrun",
"args": ["xcodebuildmcp"]
}
}
}ios-simulator-mcp
Install with npm and add it to your MCP configuration:
npm install -g ios-simulator-mcpThen add it to your MCP config:
{
"mcpServers": {
"ios-simulator-mcp": {
"command": "npx",
"args": ["-y", "ios-simulator-mcp"]
}
}
}qckfx
qckfx has one-click MCP installation from the menu bar. After installing, click the menu bar icon and select Install MCP Server. Pick your agent (Claude Code, Codex, or Cursor) and the MCP server is configured automatically.
Install qckfx via Homebrew:
brew install qckfx/tap/qckfxOr download directly:
These three tools turn your AI coding agent from a code editor into a full iOS development partner. It can build your project, run your app, and verify that everything works. The feedback loop is fast, deterministic, and requires no manual intervention. Set them up once and your agent has everything it needs to ship with confidence.