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

Devin App to the App Store: Finishing an iOS Release an Autonomous Agent Started

Devin can build and test an iOS app on its cloud macOS machines and, given secrets, upload builds to TestFlight. It cannot own your Apple Developer account, test on physical iPhones, answer the App Privacy questions or talk to App Review. Release it by drawing a clear line: Devin prepares code, pipeline and drafts; a person owns identity, signing decisions, device testing and the submission.

7 min read

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 stepDevinA person on your team
Apple Developer Program, agreements, D-U-N-S for organizations–Enrolls and accepts
App record, bundle ID, name, primary languageUses the values from the repositoryCreates them in App Store Connect
App Store Connect API keyReads it from a secretCreates a team key with the least access that still allows uploads
Certificates and provisioning profilesFetches them read-onlyDecides the approach and owns the certificate store
Version and build numbers, archive, uploadRuns the laneDecides which build goes further
Testing on real devices–Runs TestFlight rounds
App Privacy, age rating, export complianceDrafts a data inventoryAnswers the questionnaires
Submission and replies to App ReviewDrafts notesSubmits 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. xcodebuild can 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.

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.