Key takeaways
- Claude Code works in your repository and terminal: it can build, test and archive with xcodebuild on a Mac, but account setup and App Store Connect decisions stay with you.
- Put the release rules into CLAUDE.md – bundle ID, signing approach, minimum iOS version, privacy manifest – so every session works toward a shippable build.
- Uploads need Xcode 26 and the iOS 26 SDK; keep the agent from changing signing settings or entitlements without review.
- Most rejections of agent-built apps are not about code quality but about completeness, login, privacy answers and missing native value – check those before you submit.
What Claude Code can – and cannot – do for an App Store release
Claude Code is Anthropic's agentic coding tool. It reads your repository, edits files and runs commands in your terminal or IDE, and it can keep working through a build–fix–rebuild loop until something compiles. For an iOS project on a Mac, that means it can call xcodebuild, run unit tests on a simulator, read the build log and fix what broke.
What it cannot do is everything that happens outside your machine and requires your identity:
- enrolling in the Apple Developer Program and accepting the agreements in App Store Connect,
- creating the app record, choosing the name, the primary language and the SKU,
- answering the App Privacy questionnaire, the age rating and the export compliance questions on your behalf,
- replying to App Review when a reviewer asks a question or rejects a build.
So the useful question is not "can the agent publish my app?" but "which parts of the release should the agent prepare, and which parts do I keep?". The rest of this guide follows that split.
Step 1: Make the repository release-aware
Claude Code reads a CLAUDE.md file at the start of every session. Most teams use it for coding conventions; for an app that is heading to the App Store, add the release facts the agent would otherwise guess:
- the bundle identifier and the team the app belongs to (never let the agent invent a new one),
- the signing approach – Xcode automatic signing for small projects, fastlane match for teams and CI,
- the deployment target and the device families (iPhone only, or iPhone and iPad – Apple reviews on iPad too if you support it),
- the commands for building and testing, for example the exact
xcodebuildscheme and destination, - a short list of files the agent must not change without asking: entitlements,
Info.plistpermission texts, the privacy manifest and the signing configuration.
Our article on CLAUDE.md and AGENTS.md for mobile projects has a structure you can copy, and Claude Code for SwiftUI covers the build loop in more detail.
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.
Step 2: Signing, archives and uploads
Code signing is where agent-built projects most often stall. The agent can write a Fastfile, configure match for certificates and profiles, and add an App Store Connect API key to your CI secrets – but the decisions behind it need a human:
| Task | Let Claude Code do it | Keep it human |
|---|---|---|
| Build settings, schemes, version and build numbers | Yes, with review | Approve changes to the team and bundle ID |
| fastlane lanes for tests, archive and TestFlight upload | Yes | Create the API key and store it as a secret |
| Certificates and provisioning profiles | Configure match or automatic signing | Own the Apple account and the certificate repository |
| Upload of the build | Run the lane in CI | Decide which build goes to review |
Two requirements are easy to miss. First, Apple only accepts uploads built with Xcode 26 and the iOS 26 SDK or later, so make sure the Mac or the CI runner that archives the app has it. Second, every app and many SDKs need a privacy manifest. If an upload is flagged with ITMS-91053, our guide to missing API declarations explains the fix – and our playbook on privacy manifests with AI agents shows how to let the agent draft it safely.
Step 3: TestFlight before App Review
An agent tests what it is told to test. Real people find the gaps: the empty state nobody prompted for, the sign-up flow that breaks without network, the button that only works on a large iPhone. Send every build through TestFlight first – internal testers right away, external testers after the short beta review.
Ask testers to try the paths a reviewer will try: install, open, register, log in, use the core feature, buy something if you sell anything, delete the account. Then hand the findings back to Claude Code as concrete tasks, one bug per task, each with steps to reproduce. Our TestFlight playbook for AI-built apps describes a feedback loop that works with agents.
Step 4: Review readiness – the part agents underestimate
Agent-written code is rarely what gets an app rejected. Missing context is. Before you submit, check the points App Review looks at in almost every first submission:
- Completeness. No placeholder screens, sample data or dead buttons. Agents like to scaffold features "for later"; remove them or finish them. See Guideline 2.1.
- Native value. If the app mostly shows web content, it needs features that make it more than a website. See Guideline 4.2.
- Login and accounts. Third-party login usually means offering Sign in with Apple as well, and every account people can create must be deletable inside the app.
- Payments. Digital content and subscriptions bought inside the app go through In-App Purchase.
- Review notes. A demo account that works, plus a plain description of every feature – including anything behind a paywall, a role or a feature flag.
Our App Store review checklist for AI-built apps turns this into a list you can run before every submission.
After approval: keep the agent on a short leash
Once the app is live, every update goes through review again. Changes that look harmless to an agent – a new permission, a different analytics SDK, a login provider – change your privacy answers or trigger new guideline checks. Keep a release checklist in the repository, let Claude Code run it as part of the release lane, and review diffs to entitlements, permission texts and the privacy manifest yourself.
If you also want the app on Android, the same repository habits carry over; the store side does not. Read Claude Code app to Google Play for the differences – upload keys, App Bundles and the closed test for new personal accounts.
And if you would rather hand the release off entirely: our AI Code Engineers set up signing and CI/CD, prepare the listing and privacy details and handle the review conversation in your own accounts – see the iOS submission service.
Release checklist for a Claude Code iOS app
- CLAUDE.md names the bundle ID, team, signing approach, deployment target and protected files.
- The app archives with Xcode 26 and the iOS 26 SDK on your Mac or CI runner.
- Signing is reproducible (automatic signing or fastlane match) and the API key lives in CI secrets.
- Privacy manifest and App Privacy answers match the SDKs and data flows actually in the app.
- TestFlight testers have run install, sign-up, login, core feature, purchase and account deletion.
- No placeholder screens, sample data or unfinished features remain.
- Review notes include a working demo account and describe every feature.
Frequently asked questions
Can Claude Code upload my app to App Store Connect?
It can run the commands that upload a build – for example a fastlane lane in your CI – once you have created the app record, the signing assets and an App Store Connect API key. Creating the account, the app record and the review submission stay with you.
Do I need a Mac to ship an iOS app built with Claude Code?
You need macOS with Xcode somewhere: on your own Mac or on a macOS CI runner such as GitHub Actions, Bitrise, Codemagic or Xcode Cloud. Claude Code itself can run on other systems, but the iOS build and archive steps need Xcode.
Will Apple reject my app because it was written by an AI agent?
App Review judges the app, not the tool that wrote it. Agent-built apps get rejected for the same reasons as any other app – incomplete features, missing native value, login, payment or privacy issues. Those are the checks to focus on.
Can you help us release our Claude Code app?
Yes. Book a free call and an AI Code Engineer looks at your project with you. If you want us to take over, we set up signing and CI/CD, prepare the store listing and handle the submission and review communication 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.