Swift Expert

Core Workflow

• Architecture Analysis - Identify platform targets, dependencies, design patterns

• Design Protocols - Create protocol-first APIs with associated types

• Implement - Write type-safe code with async/await and value semantics

• Optimize - Profile with Instruments, ensure thread safety

• Test - Write comprehensive tests with XCTest and async patterns

Validation checkpoints: After step 3, run swift build to verify compilation. After step 4, run swift build -warnings-as-errors to surface actor isolation and Sendable warnings. After step 5, run swift test and confirm all async tests pass.

Reference Guide

Load detailed guidance based on context:

Topic

Reference

Load When

SwiftUI

references/swiftui-patterns.md

Building views, state management, modifiers

Concurrency

references/async-concurrency.md

async/await, actors, structured concurrency

Protocols

references/protocol-oriented.md

Protocol design, generics, type erasure

Memory

references/memory-performance.md

ARC, weak/unowned, performance optimization

Testing

references/testing-patterns.md

XCTest, async tests, mocking strategies

Code Patterns

async/await — Correct vs. Incorrect

// ✅ DO: async/await with structured error handling

func fetchUser(id: String) async throws -> User {

    let url = URL(string: "https://api.example.com/users/\(id)")!

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

    return try JSONDecoder().decode(User.self, from: data)

}

// ❌ DON'T: mixing completion handlers with async context

func fetchUser(id: String) async throws -> User {

    return try await withCheckedThrowingContinuation { continuation in

        // Avoid wrapping existing async APIs this way when a native async version exists

        legacyFetch(id: id) { result in

            continuation.resume(with: result)

        }

    }

}

SwiftUI State Management

// ✅ DO: use @Observable (Swift 5.9+) for view models

@Observable

final class CounterViewModel {

    var count = 0

    func increment() { count += 1 }

}

struct CounterView: View {

    @State private var vm = CounterViewModel()

    var body: some View {

        VStack {

            Text("\(vm.count)")

            Button("Increment", action: vm.increment)

        }

    }

}

// ❌ DON'T: reach for ObservableObject/Published when @Observable suffices

class LegacyViewModel: ObservableObject {

    @Published var count = 0  // Unnecessary boilerplate in Swift 5.9+

}

Protocol-Oriented Architecture

// ✅ DO: define capability protocols with associated types

protocol Repository<Entity> {

    associatedtype Entity: Identifiable

    func fetch(id: Entity.ID) async throws -> Entity

    func save(_ entity: Entity) async throws

}

struct UserRepository: Repository {

    typealias Entity = User

    func fetch(id: UUID) async throws -> User { /* … */ }

    func save(_ user: User) async throws { /* … */ }

}

// ❌ DON'T: use classes as base types when a protocol fits

class BaseRepository {  // Avoid class inheritance for shared behavior

    func fetch(id: UUID) async throws -> Any { fatalError("Override required") }

}

Actor for Thread Safety

// ✅ DO: isolate mutable shared state in an actor

actor ImageCache {

    private var cache: [URL: UIImage] = [:]

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

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

}

// ❌ DON'T: use a class with manual locking

class UnsafeImageCache {

    private var cache: [URL: UIImage] = [:]

    private let lock = NSLock()  // Error-prone; prefer actor isolation

    func image(for url: URL) -> UIImage? {

        lock.lock(); defer { lock.unlock() }

        return cache[url]

    }

}

Constraints

MUST DO

• Use type hints and inference appropriately

• Follow Swift API Design Guidelines

• Use async/await for asynchronous operations (see pattern above)

• Ensure Sendable compliance for concurrency

• Use value types (struct/enum) by default

• Document APIs with markup comments (/// …)

• Use property wrappers for cross-cutting concerns

• Profile with Instruments before optimizing

MUST NOT DO

• Use force unwrapping (!) without justification

• Create retain cycles in closures

• Mix synchronous and asynchronous code improperly

• Ignore actor isolation warnings

• Use implicitly unwrapped optionals unnecessarily

• Skip error handling

• Use Objective-C patterns when Swift alternatives exist

• Hardcode platform-specific values

Output Templates

When implementing Swift features, provide:

• Protocol definitions and type aliases

• Model types (structs/classes with value semantics)

• View implementations (SwiftUI) or view controllers

• Tests demonstrating usage

• Brief explanation of architectural decisions

Documentation