Use Gemini Code Assist to scaffold SwiftUI views, generate previews, and wire up state — then verify everything in Xcode. A practical step-by-step for building UI faster with AI.
SwiftUI is declarative and pattern-heavy. Stacks, modifiers, list rows, and preview providers repeat constantly across a codebase.
That repetition is exactly where an AI assistant pays off. Gemini Code Assist can scaffold a view, fill in modifier chains, and produce boilerplate previews in seconds.
This guide assumes you have Gemini Code Assist installed in VS Code or a JetBrains IDE and are signed in. You will author SwiftUI here, then verify it in Xcode.
Keep one thing front of mind throughout: Gemini writes the code, but only Xcode's canvas and simulator prove it actually renders. Generate fast, verify always.
The fastest way to get a useful SwiftUI draft is comment-driven generation. Open a Swift file and write a plain-English description of what you want.
For example: `// A SwiftUI card view showing a profile image, name, and bio with rounded corners and a shadow`.
Press return and let Gemini propose an implementation. It will typically generate a `struct` conforming to `View` with a `body` containing a `VStack`, an `Image`, `Text` views, and the modifiers you described.
The more specific your comment, the closer the first draft. Mention spacing, alignment, colors, and SF Symbols names if you have them in mind.
As you type inside the view body, Gemini offers inline completions. Start a `VStack {` and it will often suggest the child views and closing brace.
Accept suggestions with Tab and reject with Escape. Do not accept blindly — read each suggestion, because SwiftUI modifier order changes behavior.
If a completion adds a modifier you did not want, delete it and keep typing; Gemini adapts to the new context on the next keystroke.
For repetitive rows — say ten similar settings toggles — write the first one, and Gemini will confidently complete the rest as you begin each line.
SwiftUI views often need `@State`, `@Binding`, `@ObservedObject`, or `@StateObject`. Ask Gemini to add them via chat for precision.
Select your view and prompt: 'Add a @State boolean to toggle this card's expanded state and animate the change.' Gemini will insert the property and wrap the layout change in `withAnimation`.
For two-way data, ask it to convert a `@State` into a `@Binding` passed from a parent. It understands the SwiftUI ownership model well enough to rewire both sides.
Always confirm the property wrappers match your intent. Mixing up `@StateObject` and `@ObservedObject` causes subtle lifecycle bugs that only surface at runtime in Xcode.
Xcode's canvas needs a preview to render your view. Gemini generates these quickly.
With your view open, prompt the chat: 'Add a SwiftUI preview with sample data for this view.' It will produce a `#Preview` block or a `PreviewProvider` populated with realistic placeholder values.
Ask for multiple previews if useful — light and dark mode, or different device sizes. Prompt 'Add previews for dark mode and a large accessibility text size.'
These previews only come alive in Xcode. Copy the generated view and preview into your Xcode project, open the canvas, and confirm it renders as expected.
Large SwiftUI bodies get unwieldy. Gemini is good at extraction refactors.
Select a chunk of your body and ask: 'Extract this into a separate SwiftUI subview called ProfileHeader.' Gemini creates the new struct and replaces the original block with a call to it.
This keeps view bodies readable and improves compile times, since the Swift compiler struggles with deeply nested view expressions.
You can also ask it to pull repeated modifier chains into a custom `ViewModifier` or a `View` extension. Review the result — extraction sometimes needs you to pass in bindings or environment values manually.
This is the non-negotiable step. Gemini cannot see your app render, so its SwiftUI output is an educated draft, not verified UI.
Move the generated code into your Xcode project. Open the SwiftUI canvas and let it build. Watch for compiler errors — an outdated modifier name or an API not available on your deployment target is the most common problem.
Run the view on a simulator and interact with it. Confirm state changes, animations, and layout behave as intended across device sizes.
If something is off, copy the exact Xcode error back into Gemini chat and ask for a fix. That feedback loop — generate, build, paste error, refine — is how you get reliable SwiftUI from AI.
Your results improve dramatically with better prompts. Be concrete about layout, data types, and desired behavior.
Give Gemini your real model types. If you have a `User` struct, mention it so the generated view binds to actual properties instead of invented ones.
Iterate in small steps. Generate a view, verify it, then ask for one enhancement at a time — accessibility labels, then animations, then localization. Big all-in-one prompts produce more errors.
Finally, remember the boundary. Gemini and any AI accelerate SwiftUI authoring, but a shippable native app still needs Xcode to build and the Apple Developer Program to release. Cross-platform tools like Flutter and React Native do not output native SwiftUI either. Used this way, Gemini genuinely speeds up UI work without replacing the tools that own the final result.
It helps to know where the assistant reliably saves time so you reach for it in the right moments.
List and grid layouts are a sweet spot. Ask for a `List` with custom rows, a `LazyVGrid` gallery, or a `ForEach` over your model array, and Gemini scaffolds the structure with the right identifiers quickly.
Forms and settings screens are another. Describing a settings screen with toggles, pickers, and sections produces a solid first draft that you then bind to your real state, saving a lot of repetitive typing.
Gemini is also handy for common modifiers you half-remember — gradients, shadows, corner radii, conditional styling, and animation curves. Instead of hunting through documentation, you describe the effect and refine the suggestion.
Where you should slow down is anything stateful or lifecycle-sensitive: complex navigation stacks, data flow across many views, and concurrency-driven updates. Gemini can draft these, but they are exactly the areas where a plausible-looking suggestion may behave wrong at runtime, so verify them in the simulator with extra care.
No. Gemini generates the preview code, but only Xcode's canvas renders SwiftUI previews. Move the generated code into Xcode to see it live.
Not always. It can suggest outdated or unavailable APIs since it cannot see your SDK version. Always build in Xcode and feed any errors back to the chat for a fix.
Give Gemini your real model types, be specific about layout and behavior in comments or chat, and iterate one change at a time rather than requesting an entire screen at once.
They complement each other. Use a descriptive comment to scaffold a whole view, then rely on inline completions to fill in repetitive rows and modifier chains as you type.