swift-concurrency-expert

Swift Concurrency review and remediation for Swift 6.2+. Use when asked to review Swift Concurrency usage, improve concurrency compliance, or fix Swift concurrency compiler errors in a feature or file.

⭐283stars🔀11forks📁View on GitHub🕐Updated Dec 31, 2025

When & Why to Use This Skill

The Swift Concurrency Expert is a specialized Claude skill designed to audit, optimize, and fix concurrency issues in Swift 6.2+ projects. It helps developers achieve data-race safety by applying actor isolation, Sendable protocols, and modern async/await patterns, ensuring compliance with the latest Swift language standards and minimizing runtime crashes.

Use Cases

  • 1. Swift 6 Migration: Upgrading legacy Swift codebases to meet the strict concurrency requirements and compiler checks of Swift 6.2+.
  • 2. Concurrency Bug Fixing: Identifying and resolving complex compiler errors related to data races, Sendable violations, and improper actor isolation.
  • 3. UI Thread Optimization: Refactoring UI-bound types with @MainActor to ensure thread safety while offloading heavy computations to background actors.
  • 4. Architectural Refactoring: Implementing modern concurrency patterns like actors and nonisolated contexts to improve code maintainability and performance.
nameswift-concurrency-expert
descriptionSwift Concurrency review and remediation for Swift 6.2+. Use when asked to review Swift Concurrency usage, improve concurrency compliance, or fix Swift concurrency compiler errors in a feature or file.

Swift Concurrency Expert

Overview

Review and fix Swift Concurrency issues in Swift 6.2+ codebases by applying actor isolation, Sendable safety, and modern concurrency patterns with minimal behavior changes.

Workflow

1. Triage the issue

  • Capture the exact compiler diagnostics and the offending symbol(s).
  • Check project concurrency settings: Swift language version (6.2+), strict concurrency level, and whether approachable concurrency (default actor isolation / main-actor-by-default) is enabled.
  • Identify the current actor context (@MainActor, actor, nonisolated) and whether a default actor isolation mode is enabled.
  • Confirm whether the code is UI-bound or intended to run off the main actor.

2. Apply the smallest safe fix

Prefer edits that preserve existing behavior while satisfying data-race safety.

Common fixes:

  • UI-bound types: annotate the type or relevant members with @MainActor.
  • Protocol conformance on main actor types: make the conformance isolated (e.g., extension Foo: @MainActor SomeProtocol).
  • Global/static state: protect with @MainActor or move into an actor.
  • Background work: move expensive work into a @concurrent async function on a nonisolated type or use an actor to guard mutable state.
  • Sendable errors: prefer immutable/value types; add Sendable conformance only when correct; avoid @unchecked Sendable unless you can prove thread safety.

Reference material

  • See references/swift-6-2-concurrency.md for Swift 6.2 changes, patterns, and examples.
  • See references/approachable-concurrency.md when the project is opted into approachable concurrency mode.
  • See references/swiftui-concurrency-tour-wwdc.md for SwiftUI-specific concurrency guidance.