Key takeaways
- Devin's documentation describes macOS sessions with Xcode 26 and the iOS Simulator – but no physical devices, so real-device testing goes through TestFlight.
- Signing on a machine that starts fresh every session needs a read-only, repeatable setup; never let a session create or revoke certificates.
- Some pull requests change your App Store answers – new entitlements, SDKs, login providers or paywall logic deserve a human reviewer.
- Devin can draft review notes from merged pull requests; submitting and replying to App Review stays with the account holder.
What Devin can run for an iOS project
Devin is Cognition's autonomous software engineering agent. You hand it a task – in its web app, from Slack or through the API – and it works in its own cloud machine, then opens a pull request. For a long time that machine was Linux, which ruled out xcodebuild. Devin's macOS support documentation now describes macOS sessions with Xcode 26, an iOS Simulator runtime and the usual Apple command-line tools.
In practice that means a Devin session can compile your app, run unit and UI tests on a simulator, archive it and – when the App Store Connect credentials are provided as secrets – upload a build to TestFlight. Whether macOS sessions are available to you depends on your organization's setup, so check that first.
The same page is clear about the limits: no USB passthrough, so no physical iPhones or iPads, and performance measured in the virtual machine does not reflect a real device. Everything that requires your identity is outside its reach anyway.
The hand-off map: Devin, a person, or both
| Release step | Devin | A person on your team |
|---|---|---|
| Apple Developer Program, agreements, D-U-N-S for organizations | – | Enrolls and accepts |
| App record, bundle ID, name, primary language | Uses the values from the repository | Creates them in App Store Connect |
| App Store Connect API key | Reads it from a secret | Creates a team key with the least access that still allows uploads |
| Certificates and provisioning profiles | Fetches them read-only | Decides the approach and owns the certificate store |
| Version and build numbers, archive, upload | Runs the lane | Decides which build goes further |
| Testing on real devices | – | Runs TestFlight rounds |
| App Privacy, age rating, export compliance | Drafts a data inventory | Answers the questionnaires |
| Submission and replies to App Review | Drafts notes | Submits and responds |
Write this split into Devin's knowledge or a release playbook so every session starts from it. A good playbook names the lane to run, the files not to touch and the moment to stop and ask.
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.
Signing on a machine that starts fresh every session
Devin boots each session from a saved machine snapshot. Signing assets must therefore arrive the same way every time, without anyone clicking through Xcode. Two setups work well:
- fastlane match in read-only mode. Certificates and profiles live encrypted in a private repository or storage bucket you control. Devin's sessions only fetch them. Creating or renewing them is a separate, human-triggered job.
- Automatic signing with an API key.
xcodebuildcan authenticate with an App Store Connect API key and manage profiles itself. Simpler, but it gives the session more power over your account.
What to avoid: a session that "fixes" a signing error by generating a new distribution certificate. Apple limits how many a team can hold, and revoking one breaks every other machine that used it. Make it a hard rule in the playbook: on signing errors, stop and report.
Secrets belong in Devin's secret store, where sessions receive them as environment variables – never in the repository, the knowledge base or a chat message. Our article on secrets and API keys in AI-built apps covers the app side of the same problem.
Simulator green is not device green
Because Devin tests on simulators, plan at least one TestFlight round on physical devices before every submission. Focus on what simulators show poorly:
- push notifications from your real backend,
- camera, microphone, Bluetooth and location permissions and their prompts,
- Sign in with Apple with a real Apple Account,
- In-App Purchase with a sandbox tester,
- speed and memory on the oldest iPhone you support, and the iPad layout if the app runs there.
Internal testers from your App Store Connect team get builds right away; external testers after a short beta review. Turn each finding into its own Devin task with steps to reproduce and a screen recording – one issue per session keeps the pull requests small enough to review. Our TestFlight playbook for AI-built apps describes the loop.
Read Devin's pull requests like an App Reviewer would
An autonomous agent makes many small decisions per task. Most are harmless. A few silently change what you must tell Apple:
- New entitlement or capability – may need a new profile and a justification.
- New usage description in Info.plist – the purpose text is what users and reviewers read.
- New SDK – analytics, crash reporting or ads change your App Privacy answers and may need a privacy manifest.
- New login provider – third-party login brings Guideline 4.8 into play.
- Paywall or pricing logic – digital goods must stay in In-App Purchase.
- Feature flags – anything switched on after approval must be described in the review notes.
Protect these paths with code owners so a pull request that touches them needs a named human approval. Our guide to reviewing agent-generated code has a lightweight process for small teams.
Review notes and the conversation with Apple
Ask Devin for a draft: every user-facing change merged since the last release, where to find it in the app, which features require an account or a purchase, and the demo login. Read it against the actual build, cut internal jargon and submit it yourself.
If App Review rejects the build, the reply should come from a person who understands the guideline cited. Devin can then implement the fix as a normal task; our plan for an AI-generated app that was rejected walks through it.
Many teams that use Devin want the release side handled with the same reliability. Our AI Code Engineers set up signing and the TestFlight pipeline, prepare the listing and privacy details, and manage submission and review in your own Apple account – see the iOS submission service. The Android counterpart is Devin app to Google Play.
Before a Devin-built app goes to App Review
- macOS sessions are enabled and the release lane runs there with Xcode 26.
- A release playbook tells Devin which lane to run, which files to leave alone and when to stop.
- Signing assets are fetched read-only; no session can create or revoke certificates.
- The App Store Connect API key lives in Devin's secret store, not in the repository.
- A TestFlight round on physical devices covered push, permissions, sign-in and purchases.
- Code owners must approve changes to entitlements, Info.plist, the privacy manifest and paywall code.
- App Privacy answers were checked against the SDKs added since the last release.
- A person reviewed the drafted notes and submits the build.
Frequently asked questions
Can Devin build iOS apps without a Mac of my own?
According to Devin's documentation, its macOS sessions come with Xcode and the iOS Simulator, so the build itself can happen there. You still need an iPhone or a group of testers for real-device testing, because the virtual machines cannot connect physical devices.
Can Devin submit my app for App Review?
It can upload builds when you give it App Store Connect credentials as secrets. Submitting a version for review means confirming privacy answers, rights and export compliance for your organization – that decision should stay with the account holder.
How do we stop Devin from breaking code signing?
Give its sessions read-only access to signing assets, document the signing approach in its knowledge or playbook, and add a rule to stop and report on signing errors instead of creating new certificates.
Is an app built by an autonomous agent more likely to be rejected?
Apple reviews the app, not the process. Problems arise when nobody checks the store-relevant details an agent changes along the way – permissions, SDKs, login and payments. A human review of those paths prevents most surprises.
Can appsubmitter.io work alongside Devin?
Yes. Devin keeps writing code; our AI Code Engineers own the release pipeline, store listing and review communication in your accounts. Book a free call to see whether that split fits your team.
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.