swift-concurrency-agent-skill: Swift 6 Concurrency Expertise for Your AI Coding Tool

Turning on Swift 6's strict concurrency checking surfaces data races in your codebase as compile-time errors — and each one demands an isolation decision. This skill teaches your AI coding tool the triage order, so the agent proposes the right isolation fix instead of sprinkling @MainActor everywhere.

Why This Skill Matters

The README names its audience precisely: teams migrating to Swift 6 or strict concurrency who need safe defaults and quick triage, developers debugging data races, isolation errors, or flaky async tests, and anyone who wants performance-minded concurrency patterns around actors, tasks, Sendable, and async streams.

The content is distilled from Antoine van der Lee's Swift Concurrency Course and his years migrating large production codebases — packaged as a portable Agent Plugin (spec 1.0.0) that works in any tool supporting the Agent Skills open format. Client-specific manifests for Claude Code, Cursor, Codex, and pi are included, and the plugin is published in the OpenAI Plugins Directory shared by ChatGPT and Codex. It is deliberately non-opinionated: industry-standard best practices and compile-time safety, not architectural preferences.

Installation

The README's recommended path is one command:

npx skills add https://github.com/avdlee/swift-concurrency-agent-skill --skill swift-concurrency

For Claude Code, install it as a plugin:

/plugin marketplace add AvdLee/Swift-Concurrency-Agent-Skill
/plugin install swift-concurrency@swift-concurrency-agent-skill

To give everyone working in a repository the skill automatically, add the plugin to the repo's .claude/settings.json under enabledPlugins and extraKnownMarketplaces — teammates get an install prompt when they open the project. ChatGPT and Codex users can install it from the Plugins browser by searching "Swift Concurrency"; INSTALLATION.md covers pi, Gemini CLI, and manual setups.

Real Workflow: Triage a Strict-Concurrency Error Log

Ask the agent exactly what the README suggests:

Use the swift concurrency skill and analyze the current project for Swift Concurrency improvements

Verification is observable: the agent should reference the triage playbook in skills/swift-concurrency/SKILL.md and then jump into the relevant reference file for your specific error or task. That structure is the skill's value — SKILL.md holds the decision trees, and a navigation index routes into 15 reference files that carry the depth: actors.md for isolation and reentrancy, sendable.md for isolation domains, migration.md for step-by-step Swift 6 strategies, testing.md for reliable async tests, plus memory management, performance, Core Data, and more.

The coverage tracks the full migration arc: choosing between async/await, actors, tasks, and task groups; applying Sendable correctly for value and reference types; avoiding actor reentrancy and retain cycles; handling cancellation and error propagation; rewriting closure-based code to async/await; migrating from Combine or RxSwift; and testing with Swift Testing (the recommended choice) or XCTest, including withMainSerialExecutor for deterministic runs. It is also current for Swift 6.2 — default actor isolation, isolated deinit, nonisolated(nonsending) and @concurrent, and concurrency-safe notifications on iOS 26+.

Tips

• Ask for one error class at a time ("all the Sendable conformance errors first") — the reference-file layout maps directly onto that kind of triage.
• The author maintains sibling skills for SwiftUI, Core Data, and Swift Testing; we covered the SwiftUI one earlier.
• Every pattern in the references ships with code examples, so asking the agent to show the pattern before applying it is cheap.
• The skill assumes your agent is already smart, per the README — it skips the textbook explanations and keeps the decision rules.

When Not to Use This

It is a Swift-only skill — a React or Kotlin codebase gets nothing from it. And if you were hoping for architecture opinions, the README declines on purpose: it sticks to industry-standard practices and compile-time safety rather than architectural preferences, so layering and module design remain your call.

See the leaderboard for more skills.