Fix Swift Concurrency Issues

This skill reviews and fixes Swift Concurrency issues in Swift 6.2+ codebases by applying actor isolation, Sendable safety, and modern concurrency patterns while minimizing behavior changes. Its triage step captures the exact compiler diagnostics and offending symbols, checks project concurrency settings (Swift language version 6.2+, strict concurrency level, whether approachable concurrency/main-actor-by-default is enabled), identifies the current actor context (@MainActor, actor, nonisolated), and confirms whether the code is UI-bound or meant to run off the main actor. It then applies the smallest safe fix that preserves existing behavior: annotating UI-bound types with @MainActor so all stored state and methods are automatically isolated, scoping protocol conformances to @MainActor when a conforming type's members are main-actor-isolated but the protocol method isn't, protecting global/static mutable state with @MainActor or moving it into an actor, moving expensive work into a @concurrent async function on a nonisolated type (or using Task.detached) to keep it off the main actor, and for Sendable errors preferring immutable/value types, adding Sendable conformance only when actually correct, and avoiding @unchecked Sendable unless thread safety can be proven. It verifies each fix by rebuilding to confirm all concurrency diagnostics resolve with no new warnings, then running the test suite to catch regressions - since concurrency changes can introduce subtle runtime issues even on a clean build - iterating back to triage if new warnings surface. It demonstrates three complete before/after examples: annotating a SwiftUI ViewModel class with @MainActor to eliminate a data-race warning, scoping a protocol conformance extension to @MainActor to satisfy an isolation mismatch, and moving heavy computation off the main actor via either Task.detached(priority: .userInitiated) or a Swift 6.2+ @concurrent async function. Reference files provide deeper detail on Swift 6.2 concurrency changes, approachable concurrency mode, and SwiftUI-specific concurrency guidance from WWDC.

Use it when reviewing Swift concurrency usage, fixing compiler diagnostics related to concurrency, or needing guidance on actor isolation, Sendable, @MainActor, or async migration. It is scoped to Swift 6.2+ concurrency specifically, not general Swift code review or non-concurrency-related compiler errors.

Inputs: the exact Swift compiler concurrency diagnostics, the offending code, and the project's concurrency settings (language version, strict concurrency level, approachable concurrency status).
Outputs: the smallest safe code fix (actor annotation, isolated protocol conformance, moved background work, or corrected Sendable conformance) that resolves the diagnostic without introducing new warnings or test regressions.

@MainActor
class ViewModel: ObservableObject {
    @Published var title: String = ""
    func load() { title = "Loaded" }
}

iOS/macOS developers fixing Swift 6.2+ concurrency compiler errors or migrating code to strict concurrency, who need minimal, correct actor-isolation fixes rather than broad rewrites.