swift_concurrency_skill

Overview

This skill teaches Swift modern concurrency from async/await through Swift 6 strict mode, covering Tasks, TaskGroup, actors, Sendable, and structured concurrency patterns. It focuses on practical migration steps, safety rules introduced in Swift 6, and concrete examples for writing race-free asynchronous code. The content helps developers apply compile-time concurrency checks and design safe concurrent systems.

How this skill works

The material inspects key Swift concurrency primitives and patterns: async functions, Task and TaskGroup usage, actor isolation, @MainActor and global actors, and Sendable conformance. It highlights Swift 6 strict mode behavior that converts many runtime data-race issues into compile-time errors and shows fixes: wrapping state in actors, marking types Sendable, and handling isolation boundaries correctly. Code snippets and a migration checklist make applying changes straightforward.

When to use it

• When migrating a codebase from completion handlers to async/await
• When enabling Swift 6 language mode and strict concurrency checking
• When designing or refactoring shared mutable state to avoid data races
• When writing UI code that must run on the main actor
• When implementing parallel work with TaskGroup or async let

Best practices

• Enable Swift 6 mode early and follow the migration checklist
• Prefer actors for mutable shared state instead of locks
• Design and document Sendable value types from the start
• Isolate UI updates with @MainActor and keep heavy work off the main thread
• Use structured concurrency (Task, TaskGroup, async let) and handle cancellation explicitly
• Audit third-party libraries for Sendable conformance and isolation issues

Example use cases

• Convert URLSession completion-handler APIs to async/await for clearer flow and error handling
• Create an actor-based counter or bank account to eliminate global mutable state races
• Use TaskGroup to fetch many remote resources concurrently and aggregate results safely
• Annotate ViewModel with @MainActor to ensure published UI state is updated on the main thread
• Enable Swift 6 strict checking to find hidden data races during compilation rather than at runtime