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

Gemini CLI to the App Store: Shipping an iPhone App Built by Google's Terminal Agent

Gemini CLI runs in your terminal, so on a Mac it can drive xcodebuild and the simulator like any other command-line tool. The release steps around it are Apple's: certificates and provisioning profiles, an archive made with Xcode 26, TestFlight and App Review. Apps written with Google's agent often use Google services too – Google Sign-In, Firebase, the Gemini API – and those choices bring their own review checks.

6 min read

Key takeaways

  • Google moved many Gemini CLI users to Antigravity CLI in June 2026; the release process in this guide works with either, because it lives in the repository and CI.
  • On a Mac, a terminal agent can build, test and screenshot an iOS app with xcodebuild and simctl – signing and uploads are a different matter.
  • Understand the three signing pieces – distribution certificate, App ID, provisioning profile – before you let any tool automate them.
  • Google Sign-In, Firebase SDKs and the Gemini API each add an App Review check: login alternatives, privacy declarations, key handling and AI data disclosure.

First: which Google CLI are you running?

Gemini CLI is Google's open-source terminal agent: you describe a task, it reads the project, proposes changes and runs commands after your approval, guided by GEMINI.md context files and extensible through MCP servers. In May 2026 Google announced the move to Antigravity CLI: for Google AI Pro and Ultra subscribers and free individual users, Gemini CLI stopped serving requests on June 18, 2026, while access through paid Gemini API keys and enterprise plans continues.

For your App Store release, this matters less than it seems. Everything that ships the app – the Xcode project, signing, the CI pipeline, the store listing – lives outside the agent. If you switch tools, carry your instructions over to a file the new tool reads; AGENTS.md is the most portable choice.

A terminal agent on a Mac covers the build loop

iOS development has a complete command-line surface, and a terminal agent can use all of it on macOS with Xcode 26 installed:

  • xcodebuild build and xcodebuild test with an explicit scheme and simulator destination,
  • xcrun simctl to boot a simulator, install the app, open a deep link or save a screenshot,
  • Swift Package Manager commands for dependency updates.

If you run the agent in a sandbox, check that builds still reach DerivedData, the simulator runtime and – for signed builds – the login keychain; a build that works in your own shell and fails under the agent is usually a sandbox boundary. Community MCP servers that wrap Xcode and the simulator exist as well. Treat them like any dependency: read the code, pin a version, limit what they can do. Our overview of MCP servers for mobile development helps you choose.

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.

GEMINI.md for an iPhone app

Gemini CLI combines context files from several levels: a global one in your home directory, one at the project root and optional ones in subfolders. Use that layering on purpose. Personal preferences go global; release facts go into the project file, where every teammate's session sees them:

# Release facts (do not change without asking)
Bundle ID: com.example.app   Team: set in Xcode, never edited here
Deployment target: see project settings
Build: xcodebuild -scheme App -destination 'platform=iOS Simulator,name=iPhone 17' test
Protected: *.entitlements, Info.plist usage texts,
           PrivacyInfo.xcprivacy, signing settings
New SDK? Name it and check that it ships a privacy manifest.

A subfolder file next to, say, your networking module can add rules that only apply there. For a cross-tool template, see memory files for mobile projects.

Certificates and profiles: do it by hand once

Signing errors are where terminal agents lose the most time, because the fix is rarely in the code. Know the pieces before you automate them:

PieceWhat it isAgent's role
Apple Distribution certificateYour signing identity; its private key sits in a keychainNone – created by the account holder
App IDThe bundle identifier plus enabled capabilitiesCan list which capabilities the code needs
Provisioning profileTies certificate and App ID together for App Store distributionCan configure the tool that fetches it
App Store Connect API keyLets CI upload buildsReads it from CI secrets, never from chat

For a solo project, Xcode's automatic signing manages certificate and profile for you. For a team or CI, fastlane match keeps them in an encrypted repository. Either way, archive with Xcode 26 and the iOS 26 SDK – App Store Connect rejects older builds. Our fastlane setup guide shows the lanes.

Headless runs in CI – around the release, not inside it

Gemini CLI can run non-interactively with a single prompt (gemini -p "..."), and Google publishes a GitHub Action, run-gemini-cli, for pull request reviews and issue triage. Useful jobs on an iOS project:

  • comment on any pull request that changes Info.plist, entitlements or the privacy manifest, explaining the effect on App Review,
  • summarise merged changes into TestFlight "What to Test" notes,
  • check that a new dependency is mentioned in your privacy documentation.

The release job itself – archive, sign, upload to TestFlight – should stay deterministic: fastlane on a macOS runner, with secrets the agent never sees.

Review traps for apps built on Google's stack

Developers who pick Google's agent often pick Google's services, and App Review has an opinion on several of them:

  • Google Sign-In as the main login generally requires an equivalent privacy-friendly option such as Sign in with Apple (Guideline 4.8).
  • Firebase SDKs such as Analytics or Crashlytics collect data that must appear in your App Privacy answers, and their privacy manifests must be present in the build.
  • The Gemini API in the app: keep keys off the device – call it through your backend or a service designed for client access – and tell users clearly, with consent, before personal data goes to a third-party AI.
  • Accounts: deleting a Firebase Auth user is not enough; the in-app deletion must remove the account and its data (Guideline 5.1.1(v)).

Want someone to carry the release? Our AI Code Engineers set up signing and CI/CD, prepare listing and privacy answers and handle the review conversation in your Apple account – see the iOS submission service. The Android route is in Gemini CLI app to Google Play.

Gemini CLI iOS release checklist

  • Release facts live in the project GEMINI.md (or AGENTS.md if you switch tools).
  • The agent builds and tests with an explicit xcodebuild command on a Mac with Xcode 26.
  • Distribution certificate, App ID and profile were set up deliberately by the account holder.
  • The App Store Connect API key exists only in CI secrets.
  • Google Sign-In is accompanied by Sign in with Apple or an equivalent option.
  • Firebase and other SDK data collection is reflected in App Privacy.
  • No Gemini or other AI API key ships inside the app binary.
  • In-app account deletion removes the account and its data.

Frequently asked questions

Can Gemini CLI build iOS apps?

On a Mac with Xcode installed, yes – it runs xcodebuild and simctl like any terminal command. On Linux or Windows it can edit Swift code, but building, archiving and signing need macOS.

Is Gemini CLI still available?

Google moved Google AI Pro, Ultra and free individual users to Antigravity CLI in June 2026; Gemini CLI remains accessible with paid Gemini API keys and enterprise access. Check Google's current documentation for your account type.

Does Apple mind that the app was written with Gemini?

No. App Review evaluates the app, its metadata and its behaviour. What matters are the usual checks: completeness, login options, privacy declarations, payments and account deletion.

Can you take our Gemini-built app through App Review?

Yes. In a free call an AI Code Engineer looks at your project and tells you what stands between it and a release. If you hand it over, we handle signing, the pipeline, the listing and the 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.

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.