A step-by-step guide to using Firebase Studio's agentic AI and Flutter to build an app that runs on iOS, then finishing the release in Xcode.
Firebase Studio can build a Flutter app in your browser, and Flutter can target iOS. But the iOS binary itself is produced by Xcode on macOS, so plan for a two-part workflow.
Part one happens in Firebase Studio: you design, build, and iterate on your app with AI assistance. Part two happens on a Mac with Xcode: you compile, sign, and submit.
Keeping this split clear from the beginning saves frustration later. You are using Firebase Studio to move fast on the app, not to replace Apple's release tooling.
Before you begin, make sure you have a Google account, and separately plan for access to a Mac and an Apple Developer Program membership for the final steps.
Open Firebase Studio in your browser and sign in with your Google account. You will land in a workspace dashboard where you can create a new project.
When prompted for how to start, you have two broad paths. You can pick a Flutter template or starter, or you can describe your app in natural language and let the agent scaffold it.
For an iOS-bound app, make sure the resulting project is a Flutter project, not a web-only project. Flutter is what gives you a path to a compiled iOS app.
Give the workspace a clear name and let it initialize. The environment will provision a Code OSS editor, a file tree, and a terminal, all in the browser.
Use the AI chat to describe what you want in plain language. Be specific about screens, core features, and data, for example a task list with categories, a detail screen, and cloud sync.
The agent will scaffold files, create widgets, and wire up basic navigation. Review what it generates rather than accepting it blindly.
Iterate in small steps. Ask for one screen or one feature at a time, verify it in the preview, then move on. Small prompts produce more predictable, reviewable changes.
Treat the AI as a fast pair programmer. You are still the engineer responsible for the architecture, so read the generated Dart code and adjust structure where it makes sense.
One of the main reasons to build here is tight backend integration. If your app needs authentication, a database, or serverless functions, connect Firebase services now.
For data, Firestore is the common choice. For sign-in, Firebase Authentication supports email, Google, and other providers, including Sign in with Apple, which matters for App Store compliance.
Ask the agent to add the relevant Firebase packages and initialization code, then confirm the configuration in your project files. Verify that the Firebase project the app points to is one you control.
Test each integration in the preview. Confirm that reads, writes, and auth flows behave before you invest more time in UI polish.
Use the in-browser preview to run your app as you build. This tight loop is the biggest productivity win of the environment.
For Flutter, the web preview lets you validate layout and logic quickly. Remember that a web preview is not identical to an iOS device, so treat it as a fast approximation.
Keep committing to source control as you go. Firebase Studio supports Git, so connect a repository and push regularly to protect your work and enable the handoff to Xcode.
When the app feels functionally complete, do a careful pass on state management, error handling, and edge cases. AI scaffolding tends to be optimistic about the happy path.
To produce a real iOS build, you need the project on a Mac with Xcode. The cleanest path is Git: push your Flutter project from Firebase Studio, then clone it on your Mac.
On the Mac, install Flutter and the iOS toolchain if you have not already. Run the standard Flutter commands to fetch dependencies and confirm the project builds for iOS.
Flutter generates an iOS runner project. Open that in Xcode so you can manage signing, capabilities, and device testing.
At this point Firebase Studio has done its job. Everything from here is native Apple tooling, exactly as it would be for any Flutter iOS app.
In Xcode, sign in with your Apple Developer account and set the project's signing team. Xcode can manage provisioning profiles automatically for most cases.
Set a unique bundle identifier and configure any capabilities your app uses, such as push notifications or Sign in with Apple. These must match what your Firebase configuration expects.
Connect a physical iPhone or use the simulator and run the app from Xcode. Testing on a real device is essential because performance and native behaviors differ from the browser preview.
Fix any iOS-specific issues that surface, such as permission prompts, Info.plist entries, or platform channel behavior. This is normal for cross-platform apps.
When the app runs cleanly on device, archive it in Xcode and upload the build to App Store Connect. This step is entirely on Apple's side and requires the Apple Developer Program.
Complete your App Store Connect listing with metadata, screenshots, privacy details, and a description. Apple's App Review will evaluate the submission.
Be prepared for review feedback. Cross-platform apps sometimes get scrutiny around native feel and completeness, so make sure the app is genuinely functional, not a thin wrapper.
After approval, you can manage releases and updates from App Store Connect, while continuing to iterate on the app back in Firebase Studio for the next version.
Once you are shipping, the workflow becomes a loop rather than a one-way trip. New features start in Firebase Studio, then flow through Git to your Mac for the iOS build.
Decide early where native iOS files live. If you edit the iOS runner or Info.plist directly in Xcode, commit those changes so Firebase Studio does not overwrite them on the next agent task.
Treat your Git repository as the single source of truth between the two worlds. Both the browser environment and your Mac read from and write to it, which prevents drift.
A little discipline here pays off. Frequent commits, clear branch names, and a habit of pulling before you build keep the cloud-to-native handoff smooth release after release.
Yes. Firebase Studio builds the Flutter app, but compiling, signing, and submitting the iOS binary requires Xcode on macOS and an Apple Developer Program membership.
Yes, through Firebase Authentication, which supports Apple as a provider. Configuring it fully still requires setup in the Apple Developer portal and in Xcode capabilities.
No. The web preview is a fast approximation. Always test the compiled app on a real iOS device or simulator through Xcode before release.
No. It produces Flutter (Dart) or web code. Native Swift or SwiftUI is not generated, so this is a cross-platform path rather than a native one.