Key takeaways
- Jules works unattended in an Ubuntu VM: it can change Swift code but never compiles the iOS app, so a Mac must check its work.
- Plan approval is the cheapest review – reject or narrow plans that touch entitlements, permissions, login or purchases.
- A macOS build on every pull request and a regular TestFlight build from main catch what the agent could not see.
- Write small, testable iOS tasks; signing, capabilities and App Store Connect stay with people.
What "asynchronous" means for an iOS release
With a terminal or editor agent, you watch it work and stop it when it drifts. Jules is built for the opposite: you give it a task on a GitHub repository, it proposes a plan, and after you approve it, the work happens in a fresh virtual machine while you do something else. You come back to a branch or pull request.
According to the Jules documentation, every VM runs Ubuntu Linux with common developer tools preinstalled. There is no Xcode, no iOS SDK and no simulator, so Jules cannot compile a SwiftUI target or run XCTest. For an App Store app, that turns the release plan into a question of checkpoints: where does a person – or a Mac – look at the work before users do?
- the plan, before any code is written,
- the pull request, together with a macOS build,
- a TestFlight build that real people install.
The plan is your first review
Rejecting a plan costs a minute; rejecting a finished pull request costs a run and your review time. For iOS, read every plan with App Review in mind:
| If the plan… | Ask yourself |
|---|---|
edits Info.plist or adds a permission | Is the usage text accurate? Do App Privacy answers change? |
| adds a Swift package | Does it ship a privacy manifest? Does it collect data? |
| adds a login provider | Does Guideline 4.8 now require Sign in with Apple or an equivalent? |
| adds a paywall or unlockable content | Does it need In-App Purchase under Guideline 3.1.1? |
| touches entitlements or capabilities | This needs a person in Xcode and the developer portal anyway |
Narrow the plan to the code part and keep the account part for yourself. Put the same rules into AGENTS.md, which Jules reads from the repository root – our template for AGENTS.md in mobile projects is a good start.
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.
Builds happen elsewhere: wiring Jules to a Mac
Every Jules pull request should trigger a macOS CI job – GitHub Actions, Bitrise, Codemagic or Xcode Cloud – that builds for the simulator and runs your tests. Make it a required check, so nothing merges on the strength of the agent's own description.
When the job fails, Jules does not see the macOS log by itself. Copy the relevant compiler errors into a follow-up task or comment, and it fixes them like any other bug. Also tell Jules in AGENTS.md that it cannot build the app, so it lists what it could not verify instead of implying it was tested.
The VM is not useless for Swift, though. A repository setup script, which Jules runs once and snapshots for later tasks, can install the Swift toolchain for Linux. Code in a Foundation-only Swift package can then be tested inside the VM. Our GitHub Actions guide for mobile CI covers the macOS side.
A regular TestFlight build from main
An asynchronous agent can deliver several pull requests overnight. Instead of shipping each one separately, run a scheduled release workflow – daily, or on every merge – that archives main with Xcode 26 and the iOS 26 SDK, sets the build number automatically and uploads to TestFlight for your internal testers.
This is the moment where UI changes Jules made without ever seeing them get looked at on real iPhones. Testers report problems through TestFlight, and each report becomes a small, reproducible Jules task. External testers can join after Apple's beta app review. Signing for this workflow – certificates, profiles and the App Store Connect API key – lives in CI secrets, never in a Jules setup script. Read the TestFlight playbook for AI-built apps for the feedback loop.
Writing iOS tasks Jules can finish
| Good task for Jules | Better kept for a person or a local agent on a Mac |
|---|---|
| Add unit tests for the date formatting in the core package | "Fix signing" or anything about certificates and profiles |
| Replace a deprecated networking call across the codebase | Adding push notifications – needs a capability and an APNs key |
| Build the account deletion flow; list UI parts to verify on macOS | "Make the onboarding look nicer" without a visual reference |
| Remove placeholder screens and unused sample data | Changing the bundle ID, team or deployment target |
Good tasks have a clear end state and something that can be checked. Vague design wishes and account-level changes waste runs.
Submission stays a human job
When a TestFlight build is ready, the account holder takes over in App Store Connect: screenshots and description, App Privacy answers, age rating, export compliance, review notes with a demo account, then the submission. If App Review responds, a person answers – the reply may need a short video or an explanation only you can give. Common first-submission issues and their fixes are in our App Store review checklist for AI-built apps.
If nobody on your team wants to own that part, our AI Code Engineers can: macOS pipeline, signing, listing, privacy answers and the review conversation, in your own Apple account. See the iOS submission service. On Android, Jules can build in its own VM – read Jules app to Google Play.
Release plan checklist for a Jules-built iOS app
- AGENTS.md states that Jules cannot build the app and lists protected files and settings.
- Plans that touch permissions, SDKs, login, purchases or entitlements are narrowed before approval.
- A required macOS check builds and tests every Jules pull request.
- A scheduled workflow archives main with Xcode 26 and uploads to TestFlight.
- Signing secrets live in CI only, never in the Jules setup script.
- Testers have checked every UI change Jules made.
- App Store Connect answers and review notes are completed by the account holder.
Frequently asked questions
Can Jules build an iOS app?
No. Jules runs each task in an Ubuntu Linux VM, and iOS apps need Xcode on macOS to build, sign and archive. Jules can write and change the Swift code; a Mac or a macOS CI runner has to compile it.
Does Jules follow AGENTS.md?
Jules looks for an AGENTS.md file in the repository root and uses it as guidance. It is the right place for bundle ID rules, protected files and the instruction to flag unverified UI changes.
How do I give Jules feedback from a failed macOS build?
Copy the compiler errors or failing test output from your CI log into a follow-up task or a comment on the pull request. With concrete errors, the fix is usually quick.
Can you turn our Jules pull requests into an App Store release?
Yes. In a free call, an AI Code Engineer walks through the repository and your release setup with you. We can run the macOS pipeline, signing, listing and review 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.