Senior iOS

Native iOS development expertise covering Swift 5.9+, SwiftUI, UIKit, and the complete Apple ecosystem. This skill provides deep knowledge of modern iOS patterns, architecture, and tooling.

Overview

This skill provides comprehensive iOS development expertise for building native applications with Swift and SwiftUI. It covers modern concurrency patterns, architecture best practices, Xcode workflows, and App Store submission processes. Uses Python tools from the senior-mobile skill for platform detection and validation.

Quick Start

Validate iOS project configuration

python3 ../../senior-mobile/scripts/platform_detector.py --check ios --depth full

Validate for App Store submission

python3 ../../senior-mobile/scripts/app_store_validator.py --store apple --strict

Python Tools

This skill uses Python tools from the senior-mobile skill:

• platform_detector.py - Analyze iOS project configuration, provisioning, entitlements

• app_store_validator.py - Validate against App Store requirements

Full iOS analysis

python3 ../../senior-mobile/scripts/platform_detector.py --check ios --output json

Strict App Store validation

python3 ../../senior-mobile/scripts/app_store_validator.py --store apple --strict

Core Capabilities

• SwiftUI Mastery - Build modern, declarative UIs with state management, navigation, and animations

• Swift Concurrency - Implement async/await, actors, and structured concurrency patterns

• UIKit Integration - Bridge UIKit and SwiftUI, migrate legacy codebases

• Performance Optimization - Profile and optimize with Instruments, resolve memory issues

• App Store Excellence - Navigate submission requirements, TestFlight, and App Store Connect

Key Workflows

Workflow 1: SwiftUI App Development

Time: Variable based on complexity

Steps:

• Define app architecture (MVVM, TCA, or custom)

• Set up project with proper folder structure

• Implement data layer with SwiftData or Core Data

• Build UI components with SwiftUI

• Add navigation using NavigationStack

• Implement state management (@State, @Observable, @Environment)

• Write unit and UI tests

• Profile and optimize performance

Reference: references/swiftui-guide.md

Architecture Pattern (MVVM):

// Model struct User: Identifiable, Codable { let id: UUID var name: String var email: String }

// ViewModel @Observable class UserViewModel { var users: [User] = [] var isLoading = false var error: Error?

func loadUsers() async {
    isLoading = true
    defer { isLoading = false }

    do {
        users = try await userService.fetchUsers()
    } catch {
        self.error = error
    }
}

}

// View struct UserListView: View { @State private var viewModel = UserViewModel()

var body: some View {
    NavigationStack {
        List(viewModel.users) { user in
            NavigationLink(value: user) {
                UserRowView(user: user)
            }
        }
        .navigationTitle("Users")
        .task {
            await viewModel.loadUsers()
        }
        .overlay {
            if viewModel.isLoading {
                ProgressView()
            }
        }
    }
}

}

Workflow 2: UIKit to SwiftUI Migration

Time: 2-8 weeks depending on app size

Steps:

• Audit existing UIKit codebase

• Identify isolated components for migration

• Create SwiftUI wrappers using UIViewRepresentable

• Migrate screens incrementally (leaf nodes first)

• Update navigation to NavigationStack

• Replace delegates with Combine/async-await

• Migrate data layer to SwiftData

• Remove UIKit dependencies progressively

Reference: references/swift-patterns.md

Bridge Pattern:

// Wrap UIKit view for use in SwiftUI struct MapViewRepresentable: UIViewRepresentable { @Binding var region: MKCoordinateRegion var annotations: [MKAnnotation]

func makeUIView(context: Context) -> MKMapView {
    let mapView = MKMapView()
    mapView.delegate = context.coordinator
    return mapView
}

func updateUIView(_ mapView: MKMapView, context: Context) {
    mapView.setRegion(region, animated: true)
    mapView.removeAnnotations(mapView.annotations)
    mapView.addAnnotations(annotations)
}

func makeCoordinator() -> Coordinator {
    Coordinator(self)
}

class Coordinator: NSObject, MKMapViewDelegate {
    var parent: MapViewRepresentable

    init(_ parent: MapViewRepresentable) {
        self.parent = parent
    }

    func mapView(_ mapView: MKMapView, regionDidChangeAnimated: Bool) {
        parent.region = mapView.region
    }
}

}

// Embed SwiftUI in UIKit class SettingsViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad()

    let settingsView = SettingsView()
    let hostingController = UIHostingController(rootView: settingsView)

    addChild(hostingController)
    view.addSubview(hostingController.view)
    hostingController.view.frame = view.bounds
    hostingController.didMove(toParent: self)
}

}

Workflow 3: App Store Submission

Time: 1-2 days for prepared apps

Steps:

• Complete App Store Connect setup

• Configure signing and capabilities in Xcode

• Run app_store_validator.py from senior-mobile tools

• Create required screenshots and previews

• Write App Store description and metadata

• Build and upload via Xcode or Transporter

• Submit for review with detailed notes

• Monitor review status and respond to feedback

Reference: references/xcode-workflows.md

Pre-Submission Checklist:

• App icon in all required sizes (1024x1024 for App Store)

• Launch screen configured

• Info.plist privacy descriptions for all permissions

• Privacy manifest (PrivacyInfo.xcprivacy) if using required APIs

• Version and build numbers updated

• Release notes written

• Screenshots for all required device sizes

• App Preview videos (optional but recommended)

• Contact information in App Store Connect

• Export compliance information

Workflow 4: Performance Profiling with Instruments

Time: 2-4 hours per profiling session

Steps:

• Build for profiling (Product > Profile)

• Select appropriate Instruments template

• Run app through critical user flows

• Analyze captured data

• Identify bottlenecks and issues

• Implement optimizations

• Re-profile to verify improvements

Reference: references/xcode-workflows.md

Key Instruments:

Instrument Purpose When to Use

Time Profiler CPU usage analysis Slow operations, high CPU

Allocations Memory allocation tracking Memory growth, leaks

Leaks Memory leak detection Retain cycles, missing dealloc

Network Network request analysis Slow API calls, large payloads

Core Animation UI rendering performance Dropped frames, slow scrolling

SwiftUI SwiftUI view lifecycle Excessive body evaluations

Common Performance Patterns:

// Avoid: Expensive computation in body var body: some View { List(items.sorted().filtered()) { item in // BAD: Runs every render ItemRow(item: item) } }

// Better: Cache computed values @State private var sortedItems: [Item] = []

var body: some View { List(sortedItems) { item in ItemRow(item: item) } .onChange(of: items) { _, newItems in sortedItems = newItems.sorted().filtered() } }

// Best: Use @Observable with lazy computation @Observable class ItemsViewModel { var items: [Item] = []

var sortedItems: [Item] {
    // Cached automatically by @Observable
    items.sorted().filtered()
}

}

Swift Patterns

Modern Concurrency

// Structured concurrency with task groups func loadDashboard() async throws -> Dashboard { async let user = userService.fetchCurrentUser() async let notifications = notificationService.fetchUnread() async let stats = analyticsService.fetchStats()

return try await Dashboard(
    user: user,
    notifications: notifications,
    stats: stats
)

}

// Actor for thread-safe state actor ImageCache { private var cache: [URL: UIImage] = [:]

func image(for url: URL) -> UIImage? {
    cache[url]
}

func setImage(_ image: UIImage, for url: URL) {
    cache[url] = image
}

}

// MainActor for UI updates @MainActor class ProfileViewModel: ObservableObject { @Published var profile: Profile?

func loadProfile() async {
    // Automatically runs on main thread
    profile = try? await profileService.fetch()
}

}

Error Handling

// Typed throws (Swift 6) enum NetworkError: Error { case invalidURL case noData case decodingFailed(Error) case serverError(Int) }

func fetchUser(id: String) async throws(NetworkError) -> User { guard let url = URL(string: "https://api.example.com/users/\(id)") else { throw .invalidURL }

let (data, response) = try await URLSession.shared.data(from: url)

guard let httpResponse = response as? HTTPURLResponse else {
    throw .noData
}

guard httpResponse.statusCode == 200 else {
    throw .serverError(httpResponse.statusCode)
}

do {
    return try JSONDecoder().decode(User.self, from: data)
} catch {
    throw .decodingFailed(error)
}

}

Protocol-Oriented Design

// Define capability through protocols protocol Loadable { associatedtype Content var state: LoadingState<Content> { get } func load() async }

enum LoadingState<T> { case idle case loading case loaded(T) case error(Error) }

// Generic view for any loadable content struct LoadableView<Content: View, T>: View { let state: LoadingState<T> let content: (T) -> Content let onRetry: () async -> Void

var body: some View {
    switch state {
    case .idle:
        Color.clear.task { await onRetry() }
    case .loading:
        ProgressView()
    case .loaded(let data):
        content(data)
    case .error(let error):
        ErrorView(error: error, onRetry: onRetry)
    }
}

}

References

• swift-patterns.md - Swift 5.9+ patterns, concurrency, protocols

• swiftui-guide.md - SwiftUI state, navigation, lifecycle

• xcode-workflows.md - Signing, Instruments, TestFlight

Tools Integration

This skill uses Python tools from the senior-mobile skill:

Validate iOS app for App Store (from senior-mobile)

python3 ../../senior-mobile/scripts/app_store_validator.py --store apple --strict

Detect iOS project configuration

python3 ../../senior-mobile/scripts/platform_detector.py --check ios --depth full

Best Practices

SwiftUI

• Use @Observable macro (iOS 17+) over @ObservableObject

• Prefer NavigationStack over NavigationView

• Keep views small and focused

• Extract reusable components early

• Use @ViewBuilder for conditional content

Performance

• Minimize body complexity

• Use LazyVStack /LazyHStack for large lists

• Implement proper Equatable for custom types

• Avoid force unwrapping in production code

• Profile before optimizing

Architecture

• Separate concerns (View, ViewModel, Model, Service)

• Use dependency injection

• Keep business logic testable

• Document public APIs

• Follow Swift naming conventions

Success Metrics

• SwiftUI Development Speed: 50% faster than UIKit equivalent

• App Store Approval Rate: 95%+ first submission

• Code Coverage: 80%+ for business logic

• Performance: 60 FPS for all animations