Key takeaways
- An agent only becomes useful for iOS work once it can build and test the app from the command line and read the results.
- Most Xcode chaos from agents comes from the project file; folder-based project structures and Swift packages reduce it a lot.
- Agents default to older Swift and UIKit patterns unless the instruction file states the language mode, concurrency rules and UI framework.
- Signing, entitlements, permission texts and the privacy manifest stay under human review – the agent may propose, not decide.
Why iOS teams need their own workshop
General agentic coding training assumes a project that builds with one command on any machine. iOS projects do not. Teams who try coding agents on their app without preparation usually hit the same walls:
- the agent cannot see whether its change compiles because nobody gave it a working
xcodebuildcommand, - new files exist on disk but not in the target, or the
.pbxprojfile ends up in a merge conflict, - generated code mixes completion handlers,
ObservableObjectand UIKit into a SwiftUI app on Swift 6, - a well-meant change adds a permission, an entitlement or an SDK – and with it, new App Review questions.
The workshop addresses each of these on your own app. It complements the tool-specific sessions; if your team uses Claude Code, see also Claude Code for SwiftUI.
Inside Xcode or next to it?
iOS developers now have several ways to work with agents, and the workshop lets them try more than one on the same task:
| Setup | Strengths | Watch out for |
|---|---|---|
| Agents built into Xcode | Xcode 26 brought coding intelligence with ChatGPT and other providers; Xcode 26.3 added agentic coding with agents such as Anthropic's Claude Agent and OpenAI's Codex, which can use Xcode's own tools and previews | Check the current Xcode release notes for what your version supports |
| Terminal agents next to Xcode | Claude Code or the Codex CLI with full control of commands, memory files and automation | They need clear build, test and simulator commands |
| AI editors with Swift support | Cursor or VS Code with Swift extensions, comfortable for mixed web and iOS teams | Xcode is still needed for signing, archiving and some debugging |
Xcode 26.3 also makes its capabilities available through the Model Context Protocol, so external agents can use them too. More on the store side of the built-in route: Xcode coding intelligence to the App Store. For a head-to-head of two popular setups, read Claude Code vs. Cursor for iOS apps.
Talk to an AI Code Engineer about your agentic coding workshop.
In a free call we look at your team, your codebase and your goals and suggest a workshop format that fits – remote or on-site, in English or German.
Five labs on your own app
Lab 1: the build loop from the command line
Together we write the exact commands the agent will use: build for a named simulator, run the unit tests, boot a simulator with xcrun simctl when needed. We make the output readable, because a thousand lines of build log hide the one error that matters. The commands go into CLAUDE.md or AGENTS.md, and every pair proves the agent can find and fix a deliberately broken build.
Lab 2: taming the project file
Agents should not hand-edit project.pbxproj. We look at your project structure and choose a strategy: folders that Xcode keeps in sync with the file system (available since Xcode 16), local Swift packages for feature modules, or a project generator if you already use one. Then we add a rule to the instruction file and test it by asking the agent to add a new feature with several files.
Lab 3: modern Swift, on purpose
Agents learned from years of older Swift code. Without instructions they mix patterns. Participants write a short "Swift rules" section: language mode and strict concurrency, SwiftUI as the default UI framework, the Observation framework for state, Swift Testing for new tests, the minimum iOS version and which APIs that allows. Then they ask the agent to refactor a screen and check that it follows the rules.
Lab 4: tests and previews as feedback
Fast unit tests are the agent's best friend; UI tests are slow and flaky as a primary signal. We let the agent write tests for a view model first, then implement against them. SwiftUI previews with realistic sample states help humans review UI changes quickly – and the agents built into Xcode can look at previews themselves.
Lab 5: release-safe boundaries
The last lab defines what the agent may not change without human approval: signing settings and the team, entitlements, permission texts in Info.plist, the privacy manifest and anything in the release lane. The agent may prepare a fastlane lane for TestFlight uploads; a human owns certificates, API keys and the decision what goes to review. Our playbook on privacy manifests with AI agents covers the trickiest of these files.
Where agents and App Review collide
Agent-made code is not what gets apps rejected; missing context is. The workshop ends with a short review of the checks App Review applies to almost every submission and how to keep agents from creating problems:
- placeholder screens and half-built features that agents scaffold "for later" – see Guideline 2.1 on completeness,
- social login added without an equivalent option such as Sign in with Apple (Guideline 4.8),
- account creation without in-app deletion (Guideline 5.1.1(v)),
- new SDKs whose required-reason APIs are not declared, which shows up as ITMS-91053 on upload.
Remember that uploads need Xcode 26 and the iOS 26 SDK or later, so the machine or CI runner that archives must be up to date. Before every submission, run the App Store review checklist for AI-built apps and distribute builds through TestFlight first.
Preparation and running it with us
Every participant needs a Mac with a current Xcode, the simulator runtimes your app uses, the app building locally and the chosen agent installed with company access. We check these in a short call beforehand – setup problems on a workshop morning cost more time on iOS than on any other platform.
Our AI Code Engineers build, sign and submit iOS apps every week, with agents doing a large share of the coding. We run the workshop remote or on-site, in English or German. If your team builds the app but would rather not handle certificates, App Store Connect and review, our iOS submission service takes over that part.
Your iOS repository is agent-ready when
- The instruction file contains working xcodebuild commands for build and test on a named simulator.
- New files land in the right target without manual project file edits.
- Swift rules state the language mode, concurrency approach, UI framework and minimum iOS version.
- Fast unit tests cover the core logic the agent is most likely to touch.
- Signing, entitlements, permission texts and the privacy manifest are listed as protected.
- Archives are built with Xcode 26 and the iOS 26 SDK, locally or on macOS CI.
Frequently asked questions
Should we use the agents built into Xcode or a terminal agent?
Try both on the same task during the workshop. The built-in agents are closest to Xcode's tools; terminal agents give you more control over memory files, automation and CI. Many teams end up using both.
Can coding agents handle UIKit codebases?
Yes. Instructions then describe your UIKit architecture and when, if ever, new screens may use SwiftUI. The important part is consistency, not the framework.
Can the agent manage our certificates and provisioning profiles?
It can configure automatic signing or fastlane match and write the CI steps. Creating certificates, owning the Apple account and storing keys as secrets should stay with a responsible person on your team.
Do you also run Android or cross-platform versions?
Yes – see the Android workshop and the workshop for React Native and Flutter teams.
Free, 15 minutes, no obligation
Plan your agentic coding workshop with us.
Our AI Code Engineers run hands-on workshops on Claude Code, OpenAI Codex, Cursor and AI app builders – and ship apps to the App Store and Google Play every week. Tell us about your team.
AI tools, store policies and requirements change quickly – always check the current documentation of the tools and stores you use. This article is independent advice and not affiliated with or endorsed by Apple, Google, Anthropic, OpenAI or any other company or product mentioned; all trademarks belong to their owners.