Skip to content
Winter Sale from $619, until 31st December 2026 Book now
From agentic coding tool to the App Store iOS · App Store Cursor

Cursor to the App Store: Taking an App Built in Cursor Through Xcode and Review

Cursor is an AI code editor built on VS Code, and its Agent can write most of a Swift or SwiftUI app. Shipping still runs through Xcode: signing and capabilities, the archive, the upload with Xcode 26 and the review in App Store Connect. The smoothest setup uses Cursor for writing and refactoring, Xcode for the project file and the store, and project rules that keep the agent away from release settings.

6 min read

Key takeaways

  • Cursor is a great place to write Swift, but signing, capabilities, archives and uploads still happen in Xcode or in a macOS pipeline.
  • Glob-scoped project rules in .cursor/rules can mark entitlements, Info.plist, the privacy manifest and the Xcode project as hands-off.
  • Avoid having the agent and Xcode edit the project file at the same time; synchronized folders reduce how often the agent needs to touch it.
  • Cursor's cloud agents run on Linux machines, so they help with reviews and chores – not with iOS builds.

Cursor writes, Xcode ships

Cursor is a fork of VS Code with an AI Agent that edits files across your project and runs terminal commands. Swift support comes from extensions: the Swift project's own VS Code extension provides language features, and community tools add Xcode build integration. That is enough to write and refactor an entire SwiftUI app. It is not enough to ship one, because several release tasks only exist inside Xcode:

TaskCursorXcode (or a macOS pipeline)
Writing views, models, networking, testsMain toolOptional
Building and running testsVia xcodebuild in the terminal on a MacNative
Signing team, capabilities, entitlementsAvoidSigning & Capabilities editor
App icon, asset catalog, SwiftUI previewsLimitedNative
Archive and upload to App Store ConnectOnly by running scriptsOrganizer, or fastlane on CI

So the realistic workflow is not Cursor or Xcode. It is both, on the same Mac, with a clear rule about which tool owns what.

Setting up the two-window workflow

Open the project folder in Cursor and the .xcodeproj or .xcworkspace in Xcode. Then make three decisions:

  1. How the agent builds. Give Cursor's Agent the exact xcodebuild command – scheme, simulator destination, test plan – in a rule, so it checks its own work instead of hoping. SourceKit-LSP needs extra configuration to understand an Xcode project; community build-server tools generate it.
  2. Who owns the project file. If the agent edits project.pbxproj while Xcode has it open, one of them overwrites the other. Folders that Xcode keeps in sync with the file system mean new Swift files appear without project edits, which removes most conflicts.
  3. Which commands may run unattended. Build and test commands are fine. Anything involving security, keychains, provisioning profiles or git push should wait for your approval.

Our comparison Claude Code vs. Cursor for iOS apps discusses when an editor-first agent fits better than a terminal one.

Talk to an AI Code Engineer about shipping your app to the App Store.

In a free call we look at what you built, tell you honestly what stands between it and an approved release – and whether you need us at all.

Project rules that protect the release

Cursor's project rules live in .cursor/rules and can apply to specific file patterns. That makes them a good fit for release protection – the rule appears exactly when the agent is about to touch a sensitive file:

Rule: release-files (applies to *.entitlements, **/Info.plist,
      **/PrivacyInfo.xcprivacy, *.xcodeproj/**)
- Do not modify these files unless the task explicitly says so.
- If a change seems necessary, stop and explain why instead.
- Permission texts in Info.plist must describe the real use.

Rule: swift-code (applies to **/*.swift)
- Deployment target and Swift version as defined in the project.
- Build with the scheme and destination below before finishing.

Keep the rules short and concrete; a long essay is read less reliably than five precise lines. The structure in memory files for mobile projects translates directly to Cursor rules.

Signing and the archive: once by hand, then automated

Do the first release from Xcode so you understand every step. In Signing & Capabilities, select your team, confirm the bundle identifier and add the capabilities the app really uses – push notifications, Sign in with Apple, associated domains. Archive with Xcode 26 and the iOS 26 SDK, which App Store Connect requires for uploads, and distribute the archive from the Organizer.

From the second release on, move the same steps into a pipeline: fastlane on a macOS CI runner, certificates managed with match or automatic signing with an App Store Connect API key, and the build number set by CI. Cursor's Agent can write the Fastfile and the workflow; you create the key and add it to the CI secrets. Our fastlane setup guide has the details.

Cloud agents and Bugbot in an iOS team

Cursor can also run agents in the cloud. According to Cursor's documentation they work on isolated Ubuntu machines configured per repository – useful for documentation, refactors of platform-independent code, test scaffolding or dependency chores, but without Xcode they cannot compile your app target. Every cloud branch needs the same macOS build check as any other pull request before it merges.

Bugbot, Cursor's pull request reviewer, adds a second set of eyes on logic errors. It does not replace a human look at diffs to entitlements, permission texts, the privacy manifest and new SDKs – those are the changes that alter what you must declare to Apple.

Five things to verify by hand before you submit

  1. Permission texts. Each usage description says what the app does with the camera, photos or location – no generic "needs access".
  2. iPad. If the target supports iPad, reviewers may test on one. Check layouts or limit the device family (Guideline 2.4.1).
  3. Login. Third-party sign-in usually requires an equivalent option such as Sign in with Apple – see Sign in with Apple for AI-built apps.
  4. Account deletion. Users who can sign up must be able to delete their account inside the app.
  5. Privacy. The privacy manifest and the App Privacy answers in App Store Connect describe the same data the app and its SDKs collect.

If you want the whole release handled, our AI Code Engineers take Cursor projects through signing, CI/CD, the listing and the review conversation in your own Apple account – see the iOS submission service. For the Android side, read Cursor app to Google Play.

Release checklist for an iOS app built in Cursor

  • A Cursor rule contains the exact xcodebuild command the agent must run before finishing.
  • Glob-scoped rules protect entitlements, Info.plist, the privacy manifest and the Xcode project.
  • Team, bundle ID and capabilities are set in Xcode, not by the agent.
  • The app archives with Xcode 26 and the iOS 26 SDK, locally or on macOS CI.
  • Cloud agent branches pass a macOS build check before merging.
  • Permission texts, iPad layouts, login options and account deletion have been checked by a person.
  • App Privacy answers match the privacy manifest and the SDKs in the project.

Frequently asked questions

Can I ship an iOS app built in Cursor without opening Xcode?

Technically, a pipeline can archive and upload without the Xcode interface, but Xcode must be installed on the Mac or CI runner that builds. For the first release, using Xcode directly is the easiest way to get signing and capabilities right.

Does Cursor support Swift and SwiftUI?

Through extensions, yes – language features come from the Swift extension for VS Code-based editors, and the Agent writes Swift well. Previews, asset catalogs and the signing editor remain Xcode features.

Can Cursor's cloud agents build my iOS app?

No. They run on Linux machines without Xcode. Use them for work that does not need a build, and let a macOS CI job verify their branches.

Can you release our Cursor-built app?

Yes. A free call with one of our AI Code Engineers is the first step: we look at the project together and tell you what is missing. We can then take over signing, the build pipeline, the store listing and the submission in your own Apple Developer account.

Free, 15 minutes, no obligation

Get your app from agent output to approved release.

Our AI Code Engineers take apps built with Claude Code, Codex, Cursor, Lovable, Base44 and co. through signing, CI/CD, store listings and review – in your own developer accounts.

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.

Ready to ship?

Talk to an AI Code Engineer – free, 15 minutes, in English or German.

Book a call for free

Chat and hotline are open 24/7. Answers from our senior AI Code Engineers (real humans) usually take closer to 72 hours than 1 hour.