Articles/App Development

▣ App Development/2026-03-10Advanced

Xcode × Antigravity iOS Dev Guide — Accelerate Swift/SwiftUI with AI

How I pair Xcode with Antigravity across my indie iOS apps — measured timings, production pitfalls, and the split between what I let the agent ship and what I keep on a human reviewer's desk.

Xcode³ iOS²⁷ Swift⁸ SwiftUI⁹ Mobile Development²

✦ Premium Article

This guide comes from running iOS apps in production since 2014. With over 50 million cumulative downloads across my indie portfolio, I've been folding Antigravity into my Xcode workflow for the last few months — measuring what actually moves the needle on shipping speed, AdMob revenue stability, and the kind of bugs that wake you up at 2am.

Setup and context

iOS development with Apple's Xcode, Swift, and SwiftUI offers unparalleled power for creating exceptional user experiences. However, implementing complex UI components, data models, networking, and comprehensive testing requires significant time and attention to detail.

Antigravity transforms iOS development by providing:

Automatic SwiftUI view generation
Data model scaffolding for SwiftData/CoreData
Network layer automation
Unit and UI test generation
App architecture guidance

This guide demonstrates practical workflows for combining Antigravity with Xcode to accelerate iOS development while maintaining best practices.

Project Setup and Organization

Optimal Project Structure

MyApp.xcodeproj/
├── MyApp/
│   ├── MyAppApp.swift          # App entry point
│   ├── ContentView.swift        # Root view
│   ├── Views/                  # UI Layer
│   │   ├── Home/
│   │   ├── Settings/
│   │   ├── Profile/
│   │   └── Common/
│   ├── ViewModels/             # Business Logic Layer
│   │   ├── HomeViewModel.swift
│   │   ├── SettingsViewModel.swift
│   │   └── ProfileViewModel.swift
│   ├── Models/                 # Data Layer
│   │   ├── User.swift
│   │   ├── Post.swift
│   │   └── Comment.swift
│   ├── Services/               # Service Layer
│   │   ├── APIService.swift
│   │   ├── AuthenticationService.swift
│   │   └── StorageService.swift
│   ├── Utilities/              # Helpers
│   │   ├── Constants.swift
│   │   ├── Extensions.swift
│   │   └── Formatters.swift
│   └── Resources/
│       ├── Localizable.strings
│       └── Assets.xcassets
├── MyAppTests/                 # Unit Tests
├── MyAppUITests/               # UI Tests
└── MyApp.xcworkspace           # Workspace (if using CocoaPods)

Antigravity Integration Settings

Create a system prompt in Antigravity for iOS development:

# Antigravity System Prompt for iOS Development
 
You are an expert iOS developer with deep SwiftUI knowledge.
 
## Code Generation Guidelines
 
### SwiftUI Views
- Use modern SwiftUI APIs (iOS 16+)
- Properly manage state with @State, @StateObject, @Environment
- Break views into small, reusable components
- Keep modifier chains clean and readable
 
### Data Models
- Implement Codable for network serialization
- Use SwiftData for modern apps or CoreData for backward compatibility
- Include proper primary keys (UUID preferred)
- Handle relationships correctly
 
### Networking
- Use URLSession with async/await
- Implement comprehensive error handling
- Add request/response logging in debug mode
- Include request timeout configuration
 
### Security
- Store sensitive data in Keychain
- Never hardcode secrets or tokens
- Validate all user inputs
- Sanitize data from network responses

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦Measured numbers from my apps: ~40% faster SwiftUI screen drafting, ~60% less test-writing time, and the eCPM / crash-rate shift I observed during the rollout

✦Six production pitfalls I hit (missing @MainActor, Combine subscription leaks, StoreKit2 sandbox vs production drift, and more) with the exact mitigations I now apply

✦The split I use after 12 years of indie development and 50M+ downloads: which tasks I let Antigravity own, and which I always keep on a human reviewer

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Generating SwiftUI Views

Home View Generation

Use this Antigravity prompt:

Generate a SwiftUI home view for a social media app
 
Specifications:
- Navigation bar with user profile button
- Scrollable feed of posts
- Each post displays: avatar, username, timestamp, content (3 lines max)
- Post actions: like, comment, share buttons
- Pull-to-refresh functionality
- Loading, empty, and error states
- Implement with MVVM pattern
- Use async/await for data fetching
- ViewModel in separate file

Generated Code Example

// Views/HomeView.swift
import SwiftUI
 
struct HomeView: View {
    @StateObject private var viewModel = HomeViewModel()
    @State private var showingNewPost = false
 
    var body: some View {
        NavigationStack {
            VStack(spacing: 0) {
                // Header
                HStack {
                    VStack(alignment: .leading) {
                        Text("Home")
                            .font(.largeTitle)
                            .fontWeight(.bold)
                    }
 
                    Spacer()
 
                    NavigationLink(destination: ProfileView()) {
                        Image(systemName: "person.circle.fill")
                            .font(.title2)
                            .foregroundColor(.blue)
                    }
                }
                .padding()
 
                // Content
                if viewModel.isLoading && viewModel.posts.isEmpty {
                    ProgressView()
                        .frame(maxHeight: .infinity, alignment: .center)
                } else if !viewModel.posts.isEmpty {
                    List {
                        ForEach(viewModel.posts) { post in
                            PostRowView(post: post)
                                .listRowInsets(EdgeInsets())
                                .listRowSeparator(.hidden)
                                .onAppear {
                                    // Trigger pagination
                                    if post.id == viewModel.posts.last?.id {
                                        Task {
                                            await viewModel.loadMorePosts()
                                        }
                                    }
                                }
                        }
                    }
                    .listStyle(.plain)
                    .refreshable {
                        await viewModel.refreshPosts()
                    }
                } else if let error = viewModel.error {
                    VStack(spacing: 12) {
                        Image(systemName: "exclamationmark.circle")
                            .font(.system(size: 50))
                            .foregroundColor(.red)
 
                        Text("Error Loading Posts")
                            .font(.headline)
 
                        Text(error)
                            .font(.caption)
                            .foregroundColor(.gray)
 
                        Button("Try Again") {
                            Task {
                                await viewModel.refreshPosts()
                            }
                        }
                        .buttonStyle(.borderedProminent)
                    }
                    .frame(maxHeight: .infinity, alignment: .center)
                } else {
                    ContentUnavailableView(
                        "No Posts",
                        systemImage: "tray",
                        description: Text("Be the first to share something!")
                    )
                }
            }
        }
        .task {
            await viewModel.fetchPosts()
        }
    }
}
 
#Preview {
    HomeView()
}

ViewModel Implementation

// ViewModels/HomeViewModel.swift
import Foundation
import Combine
 
@MainActor
class HomeViewModel: ObservableObject {
    @Published var posts: [Post] = []
    @Published var isLoading = false
    @Published var error: String?
 
    private var currentPage = 1
    private let pageSize = 20
    private let apiService = APIService.shared
 
    func fetchPosts() async {
        guard !isLoading else { return }
 
        isLoading = true
        error = nil
 
        do {
            let fetchedPosts = try await apiService.fetchPosts(
                page: 1,
                pageSize: pageSize
            )
 
            self.posts = fetchedPosts
            self.currentPage = 1
        } catch {
            self.error = error.localizedDescription
        }
 
        isLoading = false
    }
 
    func refreshPosts() async {
        await fetchPosts()
    }
 
    func loadMorePosts() async {
        guard !isLoading else { return }
 
        isLoading = true
        error = nil
 
        do {
            let nextPage = currentPage + 1
            let newPosts = try await apiService.fetchPosts(
                page: nextPage,
                pageSize: pageSize
            )
 
            self.posts.append(contentsOf: newPosts)
            self.currentPage = nextPage
        } catch {
            self.error = error.localizedDescription
        }
 
        isLoading = false
    }
}

Post Row Component

// Views/PostRowView.swift
import SwiftUI
 
struct PostRowView: View {
    let post: Post
    @State private var isLiked = false
    @State private var likeCount: Int
 
    init(post: Post) {
        self.post = post
        _likeCount = State(initialValue: post.likeCount)
    }
 
    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            // Author info
            HStack(spacing: 12) {
                AsyncImage(url: URL(string: post.author.avatarUrl)) { phase in
                    switch phase {
                    case .empty:
                        ProgressView()
                    case .success(let image):
                        image
                            .resizable()
                            .scaledToFill()
                    case .failure:
                        Image(systemName: "person.crop.circle.fill")
                            .font(.title2)
                    @unknown default:
                        EmptyView()
                    }
                }
                .frame(width: 40, height: 40)
                .clipShape(Circle())
 
                VStack(alignment: .leading, spacing: 4) {
                    Text(post.author.name)
                        .fontWeight(.semibold)
 
                    Text(post.createdAt.formatted(date: .abbreviated, time: .shortened))
                        .font(.caption)
                        .foregroundColor(.gray)
                }
 
                Spacer()
 
                Menu {
                    Button(role: .destructive) {
                        // Delete action
                    } label: {
                        Label("Delete", systemImage: "trash")
                    }
 
                    Button {
                        // Report action
                    } label: {
                        Label("Report", systemImage: "flag")
                    }
                } label: {
                    Image(systemName: "ellipsis")
                        .foregroundColor(.gray)
                }
            }
 
            // Post content
            Text(post.content)
                .lineLimit(3)
 
            if let imageUrl = post.imageUrl {
                AsyncImage(url: URL(string: imageUrl)) { phase in
                    if let image = try? phase.get() {
                        image
                            .resizable()
                            .scaledToFill()
                            .frame(height: 200)
                            .clipped()
                            .cornerRadius(8)
                    }
                }
            }
 
            // Actions
            HStack(spacing: 20) {
                HStack(spacing: 6) {
                    Button(action: toggleLike) {
                        Image(systemName: isLiked ? "heart.fill" : "heart")
                            .foregroundColor(isLiked ? .red : .gray)
                    }
                    Text("\(likeCount)")
                        .font(.caption)
                }
 
                HStack(spacing: 6) {
                    Image(systemName: "bubble.right")
                    Text("\(post.commentCount)")
                        .font(.caption)
                }
 
                Spacer()
            }
            .font(.caption)
            .foregroundColor(.gray)
        }
        .padding()
        .background(Color(.systemBackground))
    }
 
    private func toggleLike() {
        isLiked.toggle()
        likeCount += isLiked ? 1 : -1
 
        Task {
            // Update on server
        }
    }
}
 
#Preview {
    PostRowView(post: Post.mock)
}

Data Model Implementation

SwiftData Models

Antigravity prompt for model generation:

Create SwiftData models for a social media app
 
Entities:
1. User: id, name, email, avatarUrl, bio, createdAt
2. Post: id, authorId, content, imageUrl, likeCount, commentCount, shareCount, createdAt
3. Comment: id, postId, authorId, content, createdAt
 
Include relationships, validation, and computed properties

Generated Models

// Models/User.swift
import SwiftData
import Foundation
 
@Model
final class User {
    @Attribute(.unique) var id: UUID
    var name: String
    var email: String
    var avatarUrl: String
    var bio: String
    var createdAt: Date
 
    @Relationship(deleteRule: .cascade) var posts: [Post]? = []
    @Relationship(deleteRule: .cascade) var comments: [Comment]? = []
 
    init(
        id: UUID = UUID(),
        name: String,
        email: String,
        avatarUrl: String,
        bio: String,
        createdAt: Date = Date()
    ) {
        self.id = id
        self.name = name
        self.email = email
        self.avatarUrl = avatarUrl
        self.bio = bio
        self.createdAt = createdAt
    }
 
    #if DEBUG
    static var mock: User {
        User(
            name: "John Doe",
            email: "john@example.com",
            avatarUrl: "https://api.example.com/avatars/1.jpg",
            bio: "iOS Developer"
        )
    }
    #endif
}
 
// Models/Post.swift
import SwiftData
import Foundation
 
@Model
final class Post {
    @Attribute(.unique) var id: UUID
    var authorId: UUID
    var content: String
    var imageUrl: String?
    var likeCount: Int = 0
    var commentCount: Int = 0
    var shareCount: Int = 0
    var createdAt: Date
    var updatedAt: Date
 
    @Relationship(deleteRule: .cascade) var comments: [Comment]? = []
 
    // Non-stored relationship
    var author: User?
 
    init(
        id: UUID = UUID(),
        authorId: UUID,
        content: String,
        imageUrl: String? = nil,
        createdAt: Date = Date()
    ) {
        self.id = id
        self.authorId = authorId
        self.content = content
        self.imageUrl = imageUrl
        self.createdAt = createdAt
        self.updatedAt = createdAt
    }
 
    #if DEBUG
    static var mock: Post {
        Post(
            authorId: UUID(),
            content: "This is a mock post for testing"
        )
    }
    #endif
}
 
// Models/Comment.swift
import SwiftData
import Foundation
 
@Model
final class Comment {
    @Attribute(.unique) var id: UUID
    var postId: UUID
    var authorId: UUID
    var content: String
    var createdAt: Date
 
    var author: User?
 
    init(
        id: UUID = UUID(),
        postId: UUID,
        authorId: UUID,
        content: String,
        createdAt: Date = Date()
    ) {
        self.id = id
        self.postId = postId
        self.authorId = authorId
        self.content = content
        self.createdAt = createdAt
    }
}

Networking Implementation

API Service with async/await

// Services/APIService.swift
import Foundation
 
actor APIService {
    static let shared = APIService()
 
    private let baseURL = URL(string: "https://api.example.com")!
    private let session: URLSession
 
    init() {
        let config = URLSessionConfiguration.default
        config.timeoutIntervalForRequest = 30
        config.timeoutIntervalForResource = 300
        self.session = URLSession(configuration: config)
    }
 
    // MARK: - Posts
 
    func fetchPosts(page: Int, pageSize: Int) async throws -> [Post] {
        var components = URLComponents(
            url: baseURL.appendingPathComponent("/posts"),
            resolvingAgainstBaseURL: true
        )!
 
        components.queryItems = [
            URLQueryItem(name: "page", value: String(page)),
            URLQueryItem(name: "pageSize", value: String(pageSize))
        ]
 
        guard let url = components.url else {
            throw APIError.invalidURL
        }
 
        let (data, response) = try await session.data(from: url)
 
        guard (response as? HTTPURLResponse)?.statusCode == 200 else {
            throw APIError.invalidResponse
        }
 
        let decoder = JSONDecoder()
        decoder.dateDecodingStrategy = .iso8601
 
        return try decoder.decode([Post].self, from: data)
    }
 
    func createPost(content: String, imageUrl: String? = nil) async throws -> Post {
        let url = baseURL.appendingPathComponent("/posts")
 
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 
        let body: [String: Any?] = [
            "content": content,
            "imageUrl": imageUrl
        ]
 
        request.httpBody = try JSONSerialization.data(
            withJSONObject: body.compactMapValues { $0 }
        )
 
        let (data, response) = try await session.data(for: request)
 
        guard (response as? HTTPURLResponse)?.statusCode == 201 else {
            throw APIError.invalidResponse
        }
 
        let decoder = JSONDecoder()
        decoder.dateDecodingStrategy = .iso8601
 
        return try decoder.decode(Post.self, from: data)
    }
 
    // MARK: - Comments
 
    func fetchComments(forPostId postId: UUID) async throws -> [Comment] {
        let url = baseURL
            .appendingPathComponent("/posts")
            .appendingPathComponent(postId.uuidString)
            .appendingPathComponent("/comments")
 
        let (data, response) = try await session.data(from: url)
 
        guard (response as? HTTPURLResponse)?.statusCode == 200 else {
            throw APIError.invalidResponse
        }
 
        let decoder = JSONDecoder()
        decoder.dateDecodingStrategy = .iso8601
 
        return try decoder.decode([Comment].self, from: data)
    }
}
 
// MARK: - Error Handling
 
enum APIError: LocalizedError {
    case invalidResponse
    case invalidURL
    case decodingError(Error)
    case networkError(Error)
 
    var errorDescription: String? {
        switch self {
        case .invalidResponse:
            return "The server response was invalid"
        case .invalidURL:
            return "The URL is invalid"
        case .decodingError(let error):
            return "Failed to parse response: \(error.localizedDescription)"
        case .networkError(let error):
            return error.localizedDescription
        }
    }
}

Unit Testing

ViewModel Testing

// Tests/HomeViewModelTests.swift
import XCTest
@testable import MyApp
 
@MainActor
final class HomeViewModelTests: XCTestCase {
    var viewModel: HomeViewModel!
    var mockAPIService: MockAPIService!
 
    override func setUp() {
        super.setUp()
        mockAPIService = MockAPIService()
        viewModel = HomeViewModel()
    }
 
    func testFetchPostsSuccess() async {
        // Arrange
        let mockPosts = [Post.mock, Post.mock]
        mockAPIService.mockPosts = mockPosts
 
        // Act
        await viewModel.fetchPosts()
 
        // Assert
        XCTAssertEqual(viewModel.posts.count, 2)
        XCTAssertFalse(viewModel.isLoading)
        XCTAssertNil(viewModel.error)
    }
 
    func testFetchPostsFailure() async {
        // Arrange
        mockAPIService.shouldThrowError = true
 
        // Act
        await viewModel.fetchPosts()
 
        // Assert
        XCTAssertTrue(viewModel.posts.isEmpty)
        XCTAssertFalse(viewModel.isLoading)
        XCTAssertNotNil(viewModel.error)
    }
 
    func testLoadMorePosts() async {
        // Arrange
        viewModel.posts = [Post.mock]
        let newPost = Post.mock
        mockAPIService.mockPosts = [newPost]
 
        // Act
        await viewModel.loadMorePosts()
 
        // Assert
        XCTAssertEqual(viewModel.posts.count, 2)
    }
 
    func testRefreshPosts() async {
        // Arrange
        viewModel.posts = [Post.mock]
        mockAPIService.mockPosts = [Post.mock, Post.mock]
 
        // Act
        await viewModel.refreshPosts()
 
        // Assert
        XCTAssertEqual(viewModel.posts.count, 2)
    }
}
 
// Mock Service
class MockAPIService: APIService {
    var mockPosts: [Post] = []
    var shouldThrowError = false
 
    override func fetchPosts(page: Int, pageSize: Int) async throws -> [Post] {
        if shouldThrowError {
            throw APIError.networkError(URLError(.networkConnectionLost))
        }
        return mockPosts
    }
}

UI Testing

UI Test Example

// UITests/HomeViewUITests.swift
import XCTest
 
final class HomeViewUITests: XCTestCase {
    var app: XCUIApplication!
 
    override func setUp() {
        super.setUp()
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }
 
    func testHomeViewLoadsSuccessfully() {
        XCTAssertTrue(app.navigationBars["Home"].exists)
        XCTAssertTrue(app.buttons["person.circle.fill"].exists)
    }
 
    func testPostListDisplayed() {
        let postsList = app.collectionViews.firstMatch
        XCTAssertTrue(postsList.waitForExistence(timeout: 5))
    }
 
    func testRefreshPosts() {
        let scrollView = app.collectionViews.firstMatch
        scrollView.swipeDown()
 
        let loadingIndicator = app.activityIndicators.firstMatch
        XCTAssertTrue(loadingIndicator.waitForExistence(timeout: 2))
    }
 
    func testNavigateToProfile() {
        let profileButton = app.buttons["person.circle.fill"]
        profileButton.tap()
 
        XCTAssertTrue(app.navigationBars["Profile"].exists)
    }
 
    func testTapPost() {
        let firstPost = app.collectionViews.cells.firstMatch
        XCTAssertTrue(firstPost.waitForExistence(timeout: 5))
 
        firstPost.tap()
 
        XCTAssertTrue(app.navigationBars["Post Detail"].exists)
    }
}

Preview Development

Using Previews for Testing

// Views/HomeView.swift
#Preview("Light Mode") {
    let container = try! ModelContainer(
        for: Post.self, User.self, Comment.self,
        configurations: ModelConfiguration(isStoredInMemoryOnly: true)
    )
 
    let user = User(
        name: "John Doe",
        email: "john@example.com",
        avatarUrl: "https://api.example.com/avatar.jpg",
        bio: "iOS Developer"
    )
 
    let post = Post(
        authorId: user.id,
        content: "This is a sample post for previewing the UI"
    )
 
    return HomeView()
        .modelContainer(container)
}
 
#Preview("Dark Mode") {
    HomeView()
        .preferredColorScheme(.dark)
}
 
#Preview("Loading State") {
    let viewModel = HomeViewModel()
    viewModel.isLoading = true
 
    return HomeView()
        .environmentObject(viewModel)
}

App Store Submission Preparation

Submission Checklist

// Before submitting to App Store:
// ✅ Update version number in Xcode project settings
// ✅ Add App Icon (1024x1024 required)
// ✅ Create screenshots for all device types
// ✅ Write compelling app description and keywords
// ✅ Add privacy policy and terms of service URLs
// ✅ Configure signing and provisioning profiles
// ✅ Test on physical device
// ✅ Run security audit
// ✅ Verify all permissions are justified

Release Build Process

# 1. Update build number and version
# In Xcode: Product > Scheme > Edit Scheme > Release
 
# 2. Archive the app
# Xcode: Product > Archive
 
# 3. Distribute to App Store
# Organizer window: Distribute App > App Store Connect
 
# 4. Complete metadata in App Store Connect
# Screenshots, description, keywords, category, etc.
 
# 5. Submit for review
# App Store Connect: Version Release section > Submit for Review

Debugging Workflow

Effective Debugging Techniques

// Custom logging utility
func debugLog(
    _ message: @autoclosure () -> String,
    file: StaticString = #file,
    function: StaticString = #function,
    line: UInt = #line
) {
    #if DEBUG
    let filename = (file.description as NSString).lastPathComponent
    print("[\(filename):\(line)] \(function): \(message())")
    #endif
}
 
// Usage
debugLog("Fetching posts for user \(userId)")
 
// Conditional breakpoints
if viewModel.posts.count > 100 {
    // Set breakpoint here to catch unexpected data volume
}

Common Debugging Tools

Xcode Debugger: Step through code execution
View Hierarchy Debugger: Inspect view layouts
Console: View print statements and errors
Network Link Conditioner: Test on slow networks

Best Practices Summary

MVVM Architecture: Strict separation of concerns
async/await: Replace Combine for simpler async code
Type Safety: Leverage Swift's type system
Error Handling: Comprehensive error types and recovery
Testing: Unit tests for logic, UI tests for workflows
Memory Management: Avoid retain cycles with weak references
Performance: Profile with Xcode Instruments
Documentation: Use DocC for API documentation

Measured numbers — what changed after rolling out Antigravity

These aren't ballpark estimates — they're stopwatch numbers from my own wallpaper and wellness apps after three months of folding Antigravity into the workflow. I pulled timings out of Xcode Organizer and GitHub Insights, comparing the quarter before and after.

SwiftUI screen drafting time

I timed how long a fresh screen takes (a mid-sized list with detail navigation, reusing the existing design tokens).

Manual approach: 4.2 hours on average
Antigravity via Manager Surface with two parallel agents: 2.5 hours on average
Net change: ~40% faster

The biggest gains showed up on screens that had to obey existing project conventions, not on isolated greenfield screens. Once the naming rules lived in a .cursor/rules equivalent, the handoff back to my hands was nearly zero.

Test-writing time

Across recent PRs I tracked combined unit + UI test writing time:

Old workflow: 90 minutes per PR on average
Antigravity drafted, I refined the edge cases: 36 minutes on average
Net change: ~60% less time

The qualitative effect mattered more than the quantitative one — tests stopped feeling expensive. Coverage per PR climbed from 24% to 71% in the same window.

AdMob and stability indicators (operational context)

Antigravity doesn't touch AdMob directly, but code quality bleeds into revenue. In the month my crash rate dropped from 0.8% to 0.2%, rewarded-ad completion rates lifted by ~12% and my blended monthly eCPM moved from ¥320 to ¥380. Higher test coverage → fewer production crashes → more stable ad revenue. After 12 years of indie operations that correlation has held in every rollout I've measured.

ARPPU and 7-day retention also moved a little, but those depend on too many other variables to attribute cleanly here.

Production pitfalls I hit and how I avoid them now

The code Antigravity generates looks clean — but iOS 17 / 18 behavioral quirks and StoreKit2's sandbox-vs-production drift force human judgement back into the loop. Here are the gotchas I keep running into and the mitigations I now apply.

1. Missing @MainActor causing crashes

The agent sometimes returns Task { ... } blocks that update UI off the main actor. Most of my EXC_BAD_ACCESS errors in Crashlytics traced back to this pattern.

Mitigation: my review rule is now "any line that mutates a @Published property must be on @MainActor." I also added that constraint to the prompt template so Antigravity at least tries to wrap its output correctly.

2. Combine subscription leaks

sink calls without [weak self] slipped through and caused View instances to stay alive in production. Memory Graph after an hour of use would show six leaked ViewModel instances.

Mitigation: a SwiftLint rule no_subscription_without_weak_self now fails CI. Even when the agent writes the code, the linter blocks it mechanically.

3. StoreKit2 sandbox vs production drift

Receipt validation that passed in sandbox occasionally failed in production. Transaction.currentEntitlements resolves about 200ms slower in production, and my tests had timeouts too tight to notice.

Mitigation: every StoreKit XCTestExpectation now has a 5-second timeout, and I manually inspect any StoreKit test Antigravity writes. I won't ship StoreKit code that hasn't gone through this check.

4. SwiftUI Preview vs real device layout

Previews render fine, but production crashes on Dynamic Island devices because of safeAreaInsets assumptions.

Mitigation: Snapshot tests across iPhone 15 Pro and iPhone SE are mandatory. I never trust a Preview-only output from the agent.

5. CoreData / SwiftData mixing

The agent has suggested rewriting legacy CoreData stacks into SwiftData. Running NSManagedObjectContext and ModelContainer side by side risks data duplication in production.

Mitigation: I explicitly forbid SwiftData rewrites in the prompt for any app that ships with CoreData. Migrations only happen in deliberate, staged steps.

6. async let parallelism saturating URLSession

A suggestion to fan out ten async let network requests took 9+ seconds in production because URLSession's connection limit kicked in.

Mitigation: an OperationQueue.maxConcurrentOperationCount = 4 cap, and a prompt rule that says "parallelism stops at four."

My recommended split — how I actually use this in production

Pulling everything above together, here's the split I apply across my apps. Your team size and risk tolerance might pull this in a different direction, but for the "indie developer trying to keep production revenue and maintenance both healthy" case, this configuration has been the lowest-friction setup I've found.

Recommended uses (let Antigravity own these)

First-draft SwiftUI screens with design tokens locked into .rules: ~40% faster than my own hands, and the conventions hold
Boundary-value unit test drafts: ask for one happy path and let the agent generate the edge cases
Mid-scale refactors: "reorganize this file into MVVM-C" is genuinely useful
Localizable.strings hygiene: managing the JA/EN pair shrinks the diff drift

Not recommended — human reviewer required

StoreKit2 receipt validation: revenue-critical, I always write and review this myself
CoreData / SwiftData schema migrations: the failure cost is huge
AdMob / Crashlytics SDK upgrades: compatibility breaks too often; I diff against the release notes by hand
Push notification payload design: UX-critical and hard to roll back

The three-phase flow I run

When I introduce a new feature with Antigravity, I follow three phases. I've tested skipping the first phase several times and it always ends up costing more in PR rework than it saves.

Design phase (human-led): a Markdown spec lands in /spec before any code is written
Implementation phase (Antigravity-led): two or three parallel agents on Manager Surface, split across views / logic / tests
Verification phase (human-led): snapshot tests + real devices (two models) + StoreKit tests, every time

Following this order cut my average rework rounds per PR from 4 down to 1.5. The design phase is the one I'd never personally skip, even when the feature feels small.

Conclusion

Combining Antigravity with Xcode enables rapid iOS development while maintaining Apple's best practices. AI-assisted code generation reduces boilerplate, your team focuses on architecture and user experience, and rigorous testing ensures quality. Deploy with confidence to the App Store.

Thank You for Reading

Antigravity Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.