ios-concurrency

Diagnose and fix iOS concurrency issues in Swift 6 code.

1.1k|81|Updated Nov 30, 2025
One-click install
npx skills add https://github.com/CharlesWiltgen/Axiom --skill ios-concurrency
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ios-concurrency
Source: https://github.com/CharlesWiltgen/Axiom/tree/main/.claude-plugin/plugins/axiom/skills/ios-concurrency
Command: npx skills add https://github.com/CharlesWiltgen/Axiom --skill ios-concurrency

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This discipline covers Swift 6 concurrency patterns, including actor isolation, Sendable conformance, and @MainActor usage, to prevent data races and improve responsiveness.

Core Features & Use Cases

  • Transitioning from callbacks to async/await
  • Choosing between @MainActor, nonisolated, and actor isolation
  • Debugging data races and concurrency errors

Quick Start

Prompt: "Refactor a completion handler into an async function using async/await."

Frequently Asked Questions about ios-concurrency

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I convert completion handlers to async/await in Swift?

Async/await replaces callback-based code with sequential syntax. Convert completion handlers by making functions `async` and using `await` instead of callbacks, improving readability and eliminating callback nesting.

What causes data races in Swift concurrent code and how do I fix them?

Data races occur when multiple tasks access shared mutable state unsafely. Fix them by using actors to isolate state, conforming types to `Sendable`, and applying `@MainActor` for UI-bound code.

When should I use @MainActor vs actor isolation in Swift?

`@MainActor` ensures code runs on the main thread for UI updates; actor isolation protects data access across any thread. Use `@MainActor` for view controllers and UI logic, actors for general concurrency safety.

Why does my app freeze during loading with async/await?

Freezing typically occurs when long-running tasks block the main thread. Move heavy work off the main thread using background actors or Task.detached, and ensure UI updates return to the main thread with `@MainActor`.

What does Sendable conformance do and when is it required?

Sendable marks types as safe to pass between isolated concurrency domains. It's required for parameters and return values crossing actor boundaries; implement it by ensuring all stored properties are Sendable.

How do I migrate existing Swift code to Swift 6 concurrency patterns?

Migrate by replacing callbacks with async/await, adding Sendable conformance to shared types, isolating mutable state in actors, and applying `@MainActor` to UI code. Address compiler warnings incrementally.