К основному содержанию
скилл CX Codex

swift-concurrency · jamesrochabrun — скилл для Claude Code: установка

Скилл swift-concurrency помогает писать, проверять и переписывать Swift-код с async/await, actors и MainActor. Нужен при переходе на Swift 6+.

MIT 151 установок ★ 236 обновлён 2026-01-14

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add jamesrochabrun/skills --skill swift-concurrency -a claude-code
Открыть на GitHub

Что делает swift-concurrency

Скилл разбирает три сценария: создание нового асинхронного кода, аудит существующего и перенос legacy-подходов на Swift 6+. Он помогает выбрать изоляцию через @MainActor, custom actor или nonisolated, спроектировать async-функции и организовать параллельную работу с async let и TaskGroup.

Для SwiftUI описаны .task, отмена задач и наследование изоляции. При аудите проверяются блокирующие вызовы, data races, Sendable-типы, лишние actors, неструктурированные Task и обработка отмены. Отдельные разделы посвящены переносу callback-кода на async/await, DispatchQueue на actors и Combine на AsyncSequence.

В примерах используются Swift 6+ и настройки Approachable Concurrency для Xcode 26+. Без проверки Task.isCancelled длинная операция не обработает отмену. Установите файл скилла в каталог Claude Code командой из инструкции.

Какие задачи решает

  • спроектировать async-функцию с нужной изоляцией
  • найти data races и нарушения Sendable
  • переписать callbacks на async/await
  • заменить DispatchQueue на actor или MainActor
  • проверить отмену и параллельные задачи

Примеры запросов агенту

  • Проверь этот Swift-код на data races, проблемы с Sendable и блокирующие вызовы.
  • Перепиши callback для загрузки пользователя на async/await с continuation.
  • Спроектируй параллельную загрузку изображений через async let и объясни выбор изоляции.

Как установить swift-concurrency

1Через Skills CLI (Vercel)

npx skills add jamesrochabrun/skills --skill swift-concurrency -a claude-code

2Вручную: положить файлы

~/.claude/skills/swift-concurrency/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/swift-concurrency/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о swift-concurrency

Как установить swift-concurrency в Claude Code?

Выполните npx skills add jamesrochabrun/skills --skill swift-concurrency -a claude-code. Файл скилла появится по пути ~/.claude/skills/swift-concurrency/SKILL.md.

Что делает swift-concurrency?

Скилл помогает создавать, проверять и рефакторить Swift-код с современными concurrency-паттернами: async/await, actors, MainActor, Sendable и TaskGroup.

Какие версии Swift и Xcode покрывает скилл?

Материалы ориентированы на Swift 6+; настройки Approachable Concurrency описаны для Xcode 26+.

Исходный текст

SKILL.md · MIT
---
name: swift-concurrency
description: Guide for building, auditing, and refactoring Swift code using modern concurrency patterns (Swift 6+). This skill should be used when working with async/await, Tasks, actors, MainActor, Sendable types, isolation domains, or when migrating legacy callback/Combine code to structured concurrency. Covers Approachable Concurrency settings, isolated parameters, and common pitfalls.
---

# Swift Concurrency

## Overview

This skill provides guidance for writing thread-safe Swift code using modern concurrency patterns. It covers three main workflows: building new async code, auditing existing code for issues, and refactoring legacy patterns to Swift 6+.

**Core principle**: Isolation is inherited by default. With Approachable Concurrency, code starts on MainActor and propagates through the program automatically. Opt out explicitly when needed.

## Workflow Decision Tree

```
What are you doing?
│
├─► BUILDING new async code
│   └─► See "Building Workflow" below
│
├─► AUDITING existing code
│   └─► See "Auditing Checklist" below
│
└─► REFACTORING legacy code
    └─► See "Refactoring Workflow" below
```

## Building Workflow

When writing new async code, follow this decision process:

### Step 1: Determine Isolation Needs

```
Does this type manage UI state or interact with UI?
│
├─► YES → Mark with @MainActor
│
└─► NO → Does it have mutable state shared across contexts?
         │
         ├─► YES → Consider: Can it live on MainActor anyway?
         │         │
         │         ├─► YES → Use @MainActor (simpler)
         │         │
         │         └─► NO → Use a custom actor (requires justification)
         │
         └─► NO → Leave non-isolated (default with Approachable Concurrency)
```

### Step 2: Design Async Functions

```swift
// PREFER: Inherit caller's isolation (works everywhere)
func fetchData(isolation: isolated (any Actor)? = #isolation) async throws -> Data {
  // Runs on whatever actor the caller is on
}

// USE WHEN: CPU-intensive work that must run in background
@concurrent
func processLargeFile() async -> Result { }

// AVOID: Non-isolated async without explicit choice
func ambiguousAsync() async { } // Where does this run?
```

### Step 3: Handle Parallel Work

```swift
// For known number of independent operations
async let avatar = fetchImage("avatar.jpg")
async let banner = fetchImage("banner.jpg")
let (a, b) = await (avatar, banner)

// For dynamic number of operations
try await withThrowingTaskGroup(of: Void.self) { group in
  for id in userIDs {
    group.addTask { try await fetchUser(id) }
  }
  try await group.waitForAll()
}
```

### Step 4: SwiftUI Integration

```swift
struct ProfileView: View {
  @State private var avatar: Image?

  var body: some View {
    avatar
      .task { avatar = await downloadAvatar() }  // Auto-cancels on disappear
      .task(id: userID) { /* Reloads when userID changes */ }
  }
}

// For user actions
Button("Save") {
  Task { await saveProfile() }  // Inherits MainActor isolation
}
```

## Auditing Checklist

When reviewing Swift concurrency code, check for these issues:

### Critical Issues (Must Fix)

- [ ] **Blocking the cooperative pool**: Look for `DispatchSemaphore.wait()`, `DispatchGroup.wait()`, or similar blocking calls inside async contexts
- [ ] **Data races**: Non-Sendable types crossing isolation boundaries without proper handling
- [ ] **Non-isolated async in non-Sendable types**: These only work from non-isolated contexts

### Common Issues (Should Fix)

- [ ] **Actor overuse**: Custom actors without justification (see "Actor Justification Test" in references)
- [ ] **Unnecessary `MainActor.run`**: Should usually be `@MainActor` on the function instead
- [ ] **Thinking async = background**: Synchronous CPU work inside async functions still blocks
- [ ] **Unstructured Tasks where structured works**: `Task { }` instead of `async let` or `TaskGroup`
- [ ] **Missing cancellation handling**: Long operations should check `Task.isCancelled`

### SwiftUI-Specific

- [ ] **Views not MainActor-isolated**: SwiftUI views should be `@MainActor` (or use `@Observable`)
- [ ] **Accessing @State from detached tasks**: Must hop back to MainActor

### Sendable Compliance

- [ ] **@unchecked Sendable overuse**: Should be rare and justified
- [ ] **Making everything Sendable**: Not all types need to cross boundaries
- [ ] **Non-Sendable closures escaping**: Check closure captures

## Refactoring Workflow

### From Callbacks to async/await

```swift
// BEFORE: Callback-based
func fetchUser(id: Int, completion: @escaping (Result<User, Error>) -> Void) {
  URLSession.shared.dataTask(with: url) { data, _, error in
    if let error { completion(.failure(error)); return }
    // ...
  }.resume()
}

// AFTER: async/await with continuation
func fetchUser(id: Int) async throws -> User {
  try await withCheckedThrowingContinuation { continuation in
    fetchUser(id: id) { result in
      continuation.resume(with: result)
    }
  }
}
```

### From DispatchQueue to Actors

```swift
// BEFORE: Queue-based protection
class BankAccount {
  private let queue = DispatchQueue(label: "account")
  private var _balance: Double = 0

  var balance: Double {
    queue.sync { _balance }
  }

  func deposit(_ amount: Double) {
    queue.async { self._balance += amount }
  }
}

// AFTER: Actor (if truly needs own isolation)
actor BankAccount {
  var balance: Double = 0

  func deposit(_ amount: Double) {
    balance += amount
  }
}

// BETTER: MainActor class (if doesn't need concurrent access)
@MainActor
class BankAccount {
  var balance: Double = 0

  func deposit(_ amount: Double) {
    balance += amount
  }
}
```

### From Combine to AsyncSequence

```swift
// BEFORE: Combine publisher
cancellable = NotificationCenter.default
  .publisher(for: .userDidLogin)
  .sink { notification in /* ... */ }

// AFTER: AsyncSequence
for await _ in NotificationCenter.default.notifications(named: .userDidLogin) {
  // Handle notification
}
```

## Quick Reference

| Keyword | Purpose |
|---------|---------|
| `async` | Function can suspend |
| `await` | Suspension point |
| `Task { }` | Start async work, inherits isolation |
| `Task.detached { }` | Start async work, no inheritance |
| `@MainActor` | Runs on main thread |
| `actor` | Type with isolated mutable state |
| `nonisolated` | Opts out of actor isolation |
| `nonisolated(nonsending)` | Inherits caller's isolation |
| `@concurrent` | Always run on background (Swift 6.2+) |
| `Sendable` | Safe to cross isolation boundaries |
| `sending` | One-way transfer of non-Sendable |
| `async let` | Start parallel work |
| `TaskGroup` | Dynamic parallel work |

## Approachable Concurrency Settings (Swift 6.2+)

For new Xcode 26+ projects, these are enabled by default:

```
SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor
SWIFT_APPROACHABLE_CONCURRENCY = YES
```

Effects:
- Everything runs on MainActor unless explicitly marked otherwise
- `nonisolated async` functions stay on caller's actor instead of hopping to background
- Sendable errors become much rarer

## Resources

For detailed technical reference, consult:

- `references/fundamentals.md` - async/await, Tasks, structured concurrency
- `references/isolation.md` - Actors, MainActor, isolation domains, inheritance
- `references/sendable.md` - Sendable protocol, non-Sendable patterns, isolated parameters
- `references/common-mistakes.md` - Detailed examples of what to avoid
- `references/glossary.md` - Complete terminology reference

**Search patterns for references:**
- Isolation: `grep -i "isolation\|actor\|mainactor\|nonisolated"`
- Sendable: `grep -i "sendable\|sending\|boundary"`
- Tasks: `grep -i "task\|taskgroup\|async let\|structured"`

© jamesrochabrun · MIT · jamesrochabrun/skills

Похожие скиллы

Все скиллы по теме «Языки программирования» →

Сначала — swift-concurrency от других авторов.

swift-concurrency AvdLee Скилл swift-concurrency для Claude Code разбирает ошибки Swift Concurrency и предлагает безопасные исправления. Он включается при миграции на Swift 6 и работе с задачами, акторами и Sendable. CX Codex +1 17 700установок swift-concurrency dpearson2699 Скилл swift-concurrency помогает устранять ошибки Sendable и изоляции акторов в Swift 6.2+, настраивать фоновые задачи и применять SE-0466. CX Codex +1 4 600установок swift-concurrency Prisma-Labs-Dev Скилл-справочник для Claude Code по Swift Concurrency: async/await, Task, TaskGroup, акторы, AsyncSequence и continuations. Даёт материалы для работы с асинхронным кодом на Swift. CX Codex +1 752установок swift-concurrency wendylabsinc Скилл swift-concurrency направляет агента при настройке async/await, акторов и миграции на Swift 6. Помогает устранять гонки данных без бездумного навешивания @MainActor. CX Codex +1 ★ 64звёзд репо guide-swift-concurrency Prisma-Labs-Dev Скилл guide-swift-concurrency настраивает проверку конкурентного кода на Swift 6.2 со strict concurrency. Он помогает находить гонки данных, изолировать акторы и заменять вызовы GCD на группы задач. CX Codex +1 539установок swift-expert https://github.com/Jeffallan Скилл swift-expert для Claude Code: архитектура, SwiftUI, async/await, акторы и тесты на Swift. Ведёт агента при написании и разборе кода под iOS и macOS. CX Codex +1 4 500установок axiom-concurrency CharlesWiltgen Скилл axiom-concurrency для работы с конкурентностью в приложениях на платформах Apple: акторы, @MainActor, Sendable, гонки данных. CX Codex +1 1 400установок swift-concurrency-pro Paul Hudson Скилл swift-concurrency-pro проверяет Swift-код на корректность конкурентности, современные API и типичные ловушки async/await. Пригодится при чтении и ревью асинхронного кода. CX Codex +1 13 100установок migrating-to-swift-concurrency kylehughes Скилл migrating-to-swift-concurrency даёт агенту руководство Apple по миграции на Swift Concurrency. Пригодится при переходе на Swift 6, устранении гонок данных и настройке изоляции акторов. CX Codex +1 ★ 58звёзд репо swift-concurrency-expert Dimillian Скилл swift-concurrency-expert проверяет и исправляет проблемы параллелизма в Swift 6.2+: добавляет Sendable, применяет @MainActor, решает предупреждения об изоляции акторов и переводит completion handlers на async/await. CX Codex +1 2 100установок

Из того же набора23

Весь набор →
openai-prompt-engineer Скилл openai-prompt-engineer для Claude Code помогает создавать и дорабатывать промпты для GPT-5 и других языковых моделей. Помогает задать структуру ответа и выбрать технику под задачу. CX Codex +1 211установок releasing-macos-apps Скилл releasing-macos-apps ведёт выпуск macOS-приложения: от обновления версии и подписи до DMG, нотарификации Apple и обновления Sparkle. CX Codex +1 210установок content-brief-generator Скилл content-brief-generator собирает подробные брифы для статей, документации, лендингов и других форматов. Он пригодится, когда автору нужны цель, аудитория, структура и SEO-ориентиры. CX Codex +1 207установок design-brief-generator design-brief-generator — скилл для Claude Code, который собирает структурированный дизайн-бриф. Он подключается к запросам о требованиях, целях и планировании дизайн-проекта. CX Codex +1 181установок llm-router Скилл llm-router отправляет запросы в OpenAI, Grok, Groq, DeepSeek или OpenRouter через SwiftOpenAI-CLI. Работает в режиме агента, поддерживает выбор модели и MCP-инструменты. CX Codex +1 149установок engineer-expertise-extractor Скилл engineer-expertise-extractor извлекает стиль кодирования, паттерны и лучшие практики инженера из его GitHub-репозиториев и создаёт структурированную базу знаний для воспроизведения его подхода. CX Codex +1 144установок technical-launch-planner Скилл technical-launch-planner помогает спланировать запуск технического продукта: определить его уровень, составить план работ и проверить готовность команды и материалов. CX Codex +1 137установок engineer-skill-creator Скилл engineer-skill-creator для Claude Code превращает профиль инженера в структурированный скилл с поиском по задачам, языкам и паттернам. Отвечает на запросы о стиле и подходах конкретного разработчика. CX Codex +1 137установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой