Overview: Shipping an AI-Built App to Real Users
Getting an iOS application created with an AI coding assistant (such as Cursor, Claude Code, Xcode with MCP, or Antigravity) into the Apple App Store involves three distinct domains of work:
- Apple Developer & Portal Administration: Enrolling in the Apple Developer Program, generating API keys, and registering your initial App Record in the App Store Connect web portal.
- Local macOS Compilation & Code Signing: Compiling your Swift, SwiftUI, Flutter, or React Native code into a signed
.ipaarchive using your distribution certificate and provisioning profile. (FlightDeck does not compile code or sign binaries; your local Mac build tools do). - FlightDeck-Assisted App Store Connect Automation: Connecting your AI assistant to FlightDeck's Model Context Protocol (MCP) server to inspect and upload your
.ipa, distribute beta builds via TestFlight, localize storefront metadata, audit pre-flight readiness, and orchestrate human-approved App Review submissions.
If you just vibe coded your first mobile app, running it in the iOS Simulator on your Mac is only the beginning. Physical iPhones cannot install raw simulator builds—Apple requires every distributed iOS application to be cryptographically signed, packaged into an .ipa archive, uploaded to Apple's ingestion servers, and evaluated against the App Store Review Guidelines.
This comprehensive guide walks you through the entire 14-step workflow from local project to a published App Store listing.
Workflow Division of Responsibilities:
- External Build Tools: Source code compilation and cryptographic code signing are performed locally on your Mac using
xcodebuild, Flutter CLI (flutter build ipa), or Fastlane. FlightDeck does not compile Swift source code or generate cryptographic certificates. - Initial App Record Registration: Reserving your app's bundle identifier, SKU, and global App Store name is performed once directly in the Apple Developer and App Store Connect web portals.
- FlightDeck Local MCP Capabilities: Once your binary is compiled and your initial App Record exists, FlightDeck connects your AI coding agent directly to App Store Connect to inspect and upload your
.ipa, distribute beta builds, audit readiness, and orchestrate review submissions under human approval.
┌────────────────────────────────────────────────────────────────────────┐
│ Phase 1: Administrative Setup & Portal Registration (Manual) │
│ [Step 1: Code App] ──> [Step 2: Developer Program] ──> [Step 3: Portal App Record] │
└───────────────────────────────────┬────────────────────────────────────┘
│
┌───────────────────────────────────▼────────────────────────────────────┐
│ Phase 2: Local Compilation & Binary Packaging (Terminal / Xcode) │
│ [Step 4: Configure Metadata] ──> [Step 5: Compile & Sign] ──> [Step 6: Export IPA] │
└───────────────────────────────────┬────────────────────────────────────┘
│
┌───────────────────────────────────▼────────────────────────────────────┐
│ Phase 3: Upload, Processing & Beta Testing (FlightDeck-Assisted) │
│ [Step 7: Connect FlightDeck] ──> [Step 8: Upload IPA] ──> [Step 9: Monitor Ingestion] ──> [Step 10: TestFlight] │
└───────────────────────────────────┬────────────────────────────────────┘
│
┌───────────────────────────────────▼────────────────────────────────────┐
│ Phase 4: Storefront Preparation & App Review (FlightDeck + Approval) │
│ [Step 11: Metadata & Visuals] ──> [Step 12: Readiness Check] ──> [Step 13: Review Draft] ──> [Step 14: Approval & Status] │
└────────────────────────────────────────────────────────────────────────┘
Phase 1: Administrative Setup & Portal Registration
Step 1: Ideation, Vibe Coding, and Local Testing
You iterate on your Swift or Flutter code using an AI coding assistant. Run your application in the iOS Simulator to confirm your core features work.
- Bundle Identifier: Choose an unambiguous bundle ID in reverse-domain format (e.g.,
com.yourcompany.appname). - Permissions: If your app accesses device sensors (camera, location, photo library), ensure
Info.plistincludes clearNS...UsageDescriptionstrings explaining why the app needs them.
Step 2: Apple Developer Program Enrollment & API Keys
To distribute software to real devices or the App Store, you must enroll in the Apple Developer Program ($99/year USD).
- Organization Identity: If registering as a business, Apple requires a valid D-U-N-S Number matching your legal entity.
- App Store Connect API Key: Generate a Team API Key in App Store Connect under Users and Access > Integrations > App Store Connect API with App Manager or Admin role. Download the
.p8private key file and note your Key ID and Issuer ID. (See our API Key Setup Guide).
Step 3: Registering the Initial App Record in App Store Connect
Apple requires the root application record to be created directly in the web portal:
- Go to developer.apple.com > Certificates, Identifiers & Profiles > Identifiers and register an App ID matching your project's Bundle Identifier.
- Open App Store Connect and navigate to Apps.
- Click + > New App, select iOS, enter your global App Name, primary language, select your registered Bundle ID, and assign an internal SKU (e.g.,
MYAPP-001).
Once created, Apple assigns your app a permanent numeric Apple App ID (e.g., 6812899314), which FlightDeck uses to manage version drafts and builds.
Phase 2: Local Compilation & Binary Packaging
Step 4: Configure Required App Metadata
Before compiling, ensure your project's Info.plist is properly configured:
- Build Version Numbers: Set
CFBundleShortVersionString(e.g.,1.0.0for marketing) andCFBundleVersion(e.g.,1for the build counter). - Export Compliance: Add
<key>ITSAppUsesNonExemptEncryption</key><false/>if your app uses standard HTTPS encryption, preventing manual compliance questionnaires on every upload (see Fixing Missing Encryption Key).
Step 5 & 6: Compile, Sign, and Export a Valid IPA
FlightDeck operates on compiled .ipa application packages. Compile your project in your terminal:
Using Xcode Command-Line Tools (xcodebuild):
# 1. Archive the project
xcodebuild archive \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-archivePath build/MyApp.xcarchive \
-configuration Release
# 2. Export the signed IPA package
xcodebuild -exportArchive \
-archivePath build/MyApp.xcarchive \
-exportPath build/output \
-exportOptionsPlist ExportOptions.plist
Using Flutter:
flutter build ipa --release --export-options-plist=ExportOptions.plist
Confirm that the output archive exists (e.g., build/output/MyApp.ipa). (For detailed export options and troubleshooting, see Uploading an IPA Without Xcode and Flutter Build IPA Guide).
Phase 3: Upload, Processing & Beta Testing
Step 7: Connect Your AI Assistant to FlightDeck
Launch FlightDeck on your Mac and add your API key credentials. FlightDeck stores your private key in the secure macOS Keychain.
Connect your AI assistant (Cursor, Claude Code, Antigravity) to FlightDeck's MCP endpoint (see Connecting Cursor to FlightDeck or Claude Code Guide).
Step 8: Upload Your IPA via Natural-Language Prompt
Rather than dealing with Transporter or web portal upload forms, command your assistant in chat:
I compiled my release binary to build/output/MyApp.ipa.
Using FlightDeck:
1. Preview the binary to verify its bundle ID, version, and signing match our App Store Connect app record.
2. If validation passes, start uploading the IPA to App Store Connect.
What Your Assistant Does:
- Calls
build_upload_previewto inspect the.ipaarchive locally, verifying bundle identifiers and binary integrity before transmitting data. - Calls
build_upload_startto stream the archive directly from your Mac to Apple's ingestion servers over encrypted HTTPS.
Direct Apple Ingestion: Under FlightDeck's native macOS architecture, binary uploads travel directly from your machine to Apple's ingestion servers over encrypted HTTPS. Private keys never leave your Mac Keychain, and no third-party cloud service ever touches your binary assets.
Step 9: Monitor Apple Ingestion and Processing
Once uploaded, Apple's ingestion servers validate symbols, asset catalogs, and signatures. Processing typically takes 5 to 20 minutes depending on binary size and Apple queue depth.
Ask your assistant to monitor the build:
Check the processing status of our uploaded build for [Your App Name]. Let me know when Apple marks the build state as VALID.
Your assistant queries builds_list until the build reports VALID. (If it reports INVALID, your assistant inspects the diagnostic rejection reason; see Why Is My TestFlight Build Stuck on Processing?).
Step 10: Configure TestFlight for Wire-Free Testing
Before submitting for public review, test the build on a physical device via TestFlight:
Our build is VALID. Please check our internal TestFlight groups for [Your App Name] and stage adding this build to our "Core Team" group so we can test on physical hardware.
- Internal Groups: Available to team members without Beta App Review once processing finishes.
- External Groups: If you wish to share a public link with friends or beta testers, ask your assistant to configure an external group. (See Sharing Pre-Release Builds with Friends).
Phase 4: Storefront Preparation & App Review
Step 11: Prepare Storefront Metadata and Visual Assets
Your App Store listing requires localized marketing copy and screenshots:
- Character Limits: App Name (max 30 chars), Subtitle (max 30 chars), Keywords (max 100 chars, comma-separated), Description (max 4,000 chars), Promotional Text (max 170 chars).
- Screenshots: At least one screenshot for each required display family (6.7" iPhone display for all iOS apps, and 12.9" iPad display if your app is universal).
Use your assistant to draft and stage updates:
Help me draft localized metadata for [Your App Name] for our English (US) storefront:
- App title: max 30 characters
- Subtitle: max 30 characters
- Keywords: max 100 characters, comma-separated, no spaces
- Description: detailed breakdown of our key features
- Support URL: https://yourdomain.com/support
- Privacy Policy URL: https://yourdomain.com/privacy
Show me the drafted copy in chat before staging changes for my approval in FlightDeck.
(For multi-language localization workflows, see Automating Multi-Language Localization and What's New).
Step 12: Run an Automated Pre-Flight Submission Readiness Check
Never submit to Apple App Review without verifying that all mandatory requirements are satisfied. Submitting with an unattached build, missing privacy policy URL, or empty screenshots results in an immediate rejection.
Prompt your assistant to run the audit:
Please run a complete pre-flight App Store submission readiness audit for [Your App Name] using FlightDeck. Check our draft version, attached build, export compliance, screenshots, descriptions, and reviewer demo credentials. Report any fatal blockers.
Your assistant executes release_readiness_check, verifying 14 structural criteria and reporting whether the release state is READY_TO_SUBMIT. (See Pre-Flight App Store Submission Readiness Check).
What Automated Preflight Verifies: Passing preflight confirms that your submission package satisfies Apple's structural API criteria. It does not replace testing on physical hardware or guarantee that Apple review specialists will approve subjective aspects of your app.
Step 13 & 14: Stage, Approve, and Monitor App Review Submission
Once all readiness checks pass, prepare the submission container:
All readiness checks passed. Please stage an App Store Review submission draft for version 1.0.0 of [Your App Name], attach our valid build, and run preflight verification. Do not submit to Apple until I review the summary.
The Human-in-the-Loop Approval Step
Submitting to Apple App Review is a binding operational action. FlightDeck presents an interactive proposal card in the native Desktop Approval Center on your Mac. You review the target application, version string, attached build number, and preflight status, then click Approve.
Once authorized, FlightDeck dispatches the submission directly to Apple's API.
Monitoring Review Progress:
Check the current review submission status for version 1.0.0 of [Your App Name].
Your assistant queries Apple's status:
WAITING_FOR_REVIEW: Your application is queued for Apple review specialists. (Turnaround times vary based on Apple's review queue volume).IN_REVIEW: An Apple review engineer is actively testing your app on physical hardware.READY_FOR_SALE: Approved! Your app is released or ready for scheduled release.REJECTED: Reviewer flagged an issue; details appear in the web portal Resolution Center. (See Diagnosing and Fixing App Store Rejections).
Division of Responsibilities Matrix
| Workflow Task | Responsible Tool / Environment | Handled via FlightDeck MCP | Human Approval Center |
|---|---|---|---|
| Ideation & Source Code | Cursor, Claude Code, Xcode | No | Local Developer |
| Developer Program & API Keys | Apple Developer Web Portal | No (One-time setup) | Web Portal |
| Register Initial App Record | App Store Connect Web Portal | No (One-time setup) | Web Portal |
| Compile & Sign IPA | xcodebuild, Flutter, Fastlane |
No (Local compilation) | Local Terminal |
| Pre-Upload Binary Inspection | FlightDeck MCP (build_upload_preview) |
Yes | Read-only |
| Stream IPA to Apple | FlightDeck MCP (build_upload_start) |
Yes | Upload confirmation |
| Monitor Processing Status | FlightDeck MCP (builds_list) |
Yes | Read-only |
| TestFlight Beta Distribution | FlightDeck MCP (beta_group_create) |
Yes | Desktop Approval Card |
| Draft & Update Metadata | FlightDeck MCP (app_store_version_localization_update) |
Yes | Desktop Approval Card |
| Pre-Flight Readiness Audit | FlightDeck MCP (release_readiness_check) |
Yes | Read-only |
| Create Review Draft | FlightDeck MCP (review_submission_create_draft) |
Yes | Desktop Approval Card |
| Dispatch to Apple App Review | FlightDeck MCP (review_submission_submit) |
Yes | Desktop Approval Card |
| App Privacy Questionnaire | App Store Connect Web Portal | No (Web only) | Web Portal |
| Resolution Center Appeals | App Store Connect Web Portal | No (Web only) | Web Portal |
Frequently Asked Questions
Does FlightDeck replace Xcode or the Apple Developer Program?
No. You still need an Apple Developer Program account ($99/year) to sign code and publish apps. You also need local build tools (xcodebuild, Flutter, or Fastlane) to compile your Swift or Dart source code into a signed .ipa file. FlightDeck handles everything from binary inspection and upload through TestFlight, metadata management, readiness audits, and review submission.
Can FlightDeck create my initial App Record on App Store Connect?
No. Apple requires the root application record (binding your bundle ID, SKU, and primary name) to be created once in the App Store Connect web portal. Once that record exists, FlightDeck can create new version drafts (app_store_version_create), attach builds, update metadata, and orchestrate review submissions.
How do I fix a rejection from Apple?
If Apple rejects your submission, check the Resolution Center in the App Store Connect web portal for the reviewer's message and any attached crash logs. Copy the message into your AI assistant, refactor your code, increment your build number, compile a new .ipa, and upload the updated binary using FlightDeck.
Related Documentation and Guides
- App Store Connect API Keys: Generating Team Keys for AI Agents
- Uploading an iOS IPA to App Store Connect Without Opening Xcode
- Automating TestFlight Beta Distribution from Your AI Coding Assistant
- Pre-Flight App Store Submission Readiness Check: Automated Audit Guide
- Creating and Submitting an App Review Draft via FlightDeck MCP
- Diagnosing and Fixing App Store Rejections with an AI Coding Assistant
- Apple Developer: App Store Review Guidelines