iOS Concurrency Router

You MUST use this skill for ANY concurrency, async/await, threading, or Swift 6 concurrency work.

When to Use

Use this router when: - Writing async/await code - Seeing concurrency errors (data races, actor isolation) - Working with @MainActor - Dealing with Sendable conformance - Optimizing Swift performance - Migrating to Swift 6 concurrency - App freezes during loading (likely main thread blocking)

Conflict Resolution

ios-concurrency vs ios-performance: When app freezes or feels slow: 1. Try ios-concurrency FIRST — Main thread blocking is the #1 cause of UI freezes. Check for synchronous work on @MainActor before profiling. 2. Only use ios-performance if concurrency fixes don't help — Profile after ruling out obvious blocking.

ios-concurrency vs ios-build: When seeing Swift 6 concurrency errors: - Use ios-concurrency, NOT ios-build — Concurrency errors are CODE issues, not environment issues - ios-build is for "No such module", simulator issues, build failures unrelated to Swift language errors

Rationale: A 2-second freeze during data loading is almost always await on main thread or missing background dispatch. Domain knowledge solves this faster than Time Profiler.

Routing Logic

Swift Concurrency Issues

Swift 6 concurrency patterns → /skill axiom-swift-concurrency - async/await patterns - @MainActor usage - Actor isolation - Sendable conformance - Data race prevention - Swift 6 migration

Swift performance → /skill axiom-swift-performance - Value vs reference types - Copy-on-write optimization - ARC overhead - Generic specialization - Collection performance

Synchronous actor access → /skill axiom-assume-isolated - MainActor.assumeIsolated - @preconcurrency protocol conformances - Legacy delegate callbacks - Testing MainActor code synchronously

Thread-safe primitives → /skill axiom-synchronization - Mutex (iOS 18+) - OSAllocatedUnfairLock (iOS 16+) - Atomic types - Lock vs actor decision

Parameter ownership → /skill axiom-ownership-conventions - borrowing/consuming modifiers - Noncopyable types (~Copyable) - ARC traffic reduction - consume operator

Concurrency profiling → /skill axiom-concurrency-profiling - Swift Concurrency Instruments template - Actor contention diagnosis - Thread pool exhaustion - Task visualization

Decision Tree

User asks about concurrency
  ├─ Concurrency errors?
  │  ├─ Data races? → swift-concurrency
  │  ├─ Actor isolation? → swift-concurrency
  │  ├─ @MainActor? → swift-concurrency
  │  └─ Sendable? → swift-concurrency
  │
  ├─ Writing async code? → swift-concurrency
  │
  ├─ assumeIsolated questions? → assume-isolated
  │
  ├─ Mutex/lock/synchronization? → synchronization
  │
  ├─ borrowing/consuming/ownership? → ownership-conventions
  │
  ├─ Profile async performance? → concurrency-profiling
  │
  └─ Performance optimization? → swift-performance

Critical Patterns

Swift 6 Concurrency (swift-concurrency): - Progressive journey: single-threaded → async → concurrent → actors - @concurrent attribute for forced background execution - Isolated conformances - Main actor mode for approachable concurrency - 11 copy-paste patterns

Swift Performance (swift-performance): - ~Copyable for non-copyable types - Copy-on-write (COW) patterns - Value vs reference type decisions - ARC overhead reduction - Generic specialization

Example Invocations

User: "I'm getting 'data race' errors in Swift 6" → Invoke: /skill axiom-swift-concurrency

User: "How do I use @MainActor correctly?" → Invoke: /skill axiom-swift-concurrency

User: "My app is slow due to unnecessary copying" → Invoke: /skill axiom-swift-performance

User: "Should I use async/await for this network call?" → Invoke: /skill axiom-swift-concurrency

User: "How do I use assumeIsolated?" → Invoke: /skill axiom-assume-isolated

User: "My delegate callback runs on main thread, how do I access MainActor state?" → Invoke: /skill axiom-assume-isolated

User: "Should I use Mutex or actor?" → Invoke: /skill axiom-synchronization

User: "What's the difference between os_unfair_lock and OSAllocatedUnfairLock?" → Invoke: /skill axiom-synchronization

User: "What does borrowing do in Swift?" → Invoke: /skill axiom-ownership-conventions

User: "How do I use ~Copyable types?" → Invoke: /skill axiom-ownership-conventions

User: "My async code is slow, how do I profile it?" → Invoke: /skill axiom-concurrency-profiling

User: "I think I have actor contention, how do I diagnose it?" → Invoke: /skill axiom-concurrency-profiling