Swift Concurrency Pro skill
Paul Hudson's skill for reviewing Swift 6.2 concurrency code: actors, Sendable, task groups, cancellation and the mistakes models actually make
- 577 ★ on the repository
- Last commit
- MIT
Minimal access
Why this level
- The skill is text instructions and reference files and runs nothing itself
- The agent reads project sources it already sees and edits them only at your request
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/swift-concurrency-proDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- The skill is text instructions and reference files and runs nothing itself
- The agent reads project sources it already sees and edits them only at your request
This is third-party code. Review the repository files before installing.
What it does
Swift Concurrency Pro reviews Swift code for concurrency correctness, modern API use and common async/await pitfalls. Its author is Paul Hudson of Hacking with Swift, who built the rules from his book on concurrency and his write-ups of what is new in Swift 6. The skill targets mistakes language models actually make: new features they were not trained on, older features they get wrong, and patterns that keep code safe and efficient. The review runs in steps. The agent first looks for dangerous patterns using the list in `references/hotspots.md`, then checks the code against Swift 6.2 behavior and examines actor reentrancy, the preference for structured concurrency over `Task {}`, cancellation, async streams, bridges between sync and async code and migration from legacy APIs. For strict-concurrency compiler errors the skill maps each diagnostic to a fix, and for tests it checks async patterns. The report is grouped by file: the line, the rule broken and a short before and after. Files with no issues are skipped, and the report ends with a prioritized list of the most impactful changes. The skill does not nitpick or invent problems, and it does not suggest `@unchecked Sendable` just to silence the compiler.
Who it is for. For iOS and macOS developers writing Swift 6 who ask an agent to review or rewrite asynchronous code.
Good fit when
- The Swift 6 compiler reports strict-concurrency errors and you need a fix that does not just mute the problem
- An agent wrote an actor and you want to check whether state changes across two `await` points
- A project is moving from Grand Central Dispatch and closures to `async/await` and task groups
- You need to find lost cancellation, stray `Task {}` calls and mistakes in `AsyncStream` and continuations
- Before a release you want async tests and the bridges between sync and async code reviewed
Not a fit when
- You need a SwiftUI interface review: the author has a separate SwiftUI Pro skill for that
- The project builds on a Swift older than 6.2: the skill targets Swift 6.2 and strict concurrency checking
- You want to teach an agent the basics of `async/await`: the skill deliberately does not repeat what models already know
- Low-level code relies on queues and locks: the skill allows GCD where it fits and does not count it as an error
Example request
Use the Swift Concurrency Pro skill to look for potential concurrency problems in this project, starting with actors and task cancellationLimitations
The skill targets Swift 6.2 and newer with strict concurrency checking. If parts of the project build with different settings, the agent should first compare the build settings of the targets and packages before drawing conclusions.
The skill is an instruction set for an agent: it runs no code and does not replace the compiler. The author deliberately keeps the material short to save tokens, so basic concepts are not spelled out.
The README names iOS 26 and Swift 6.2 as the target.
How to disable. In Claude Code remove the swift-concurrency-pro plugin through the `/plugin` menu. If you installed with `npx skills`, delete the swift-concurrency-pro folder from the agent's skills directory, project-level or global.
FAQ
How do I install Swift Concurrency Pro in Claude Code?
Add the marketplace with `/plugin marketplace add twostraws/Swift-Concurrency-Agent-Skill`, then install the plugin: `/plugin install swift-concurrency-pro@swift-concurrency-agent-skill`. Invoke it with `/swift-concurrency-pro`, optionally with a focus such as migration.
How do I invoke the skill in Codex?
With `$swift-concurrency-pro`, optionally with a task such as moving to task groups. It installs through `npx skills add https://github.com/twostraws/swift-concurrency-agent-skill --skill swift-concurrency-pro`, and the wizard lets you pick agents and scope: one project or all projects.
How does it differ from the other Swift concurrency skill?
Paul Hudson's skill is built as a step-by-step review with separate reference files for actors, cancellation, streams, bridging, diagnostics and tests. It targets the mistakes language models make and does not restate basics they already know.
What does the rule about `@unchecked Sendable` mean?
The skill forbids suggesting `@unchecked Sendable` just to remove a compiler error: it silences the diagnostic but leaves the data race. It recommends actors, value types or `sending` parameters instead, and allows the attribute only for types with internal locking that are provably thread-safe.
What other Swift skills does the author have?
The README lists SwiftUI Pro, SwiftData Pro and Swift Testing Pro, and a link to Swift Agent Skills points to a collection of skills for Swift and Apple platforms.
Discussion
No questions or reviews yet.
Related
SkillsPaul Hudson's skill for reviewing and writing SwiftUI for iOS 26: deprecated APIs, data flow, navigation, accessibility, performance
A set of skills for iOS 26+, Swift 6.3 and SwiftUI that gives the agent knowledge of modern Apple frameworks
A SwiftUI best practices skill: state, view composition, performance, new APIs, Liquid Glass and Instruments trace analysis
A skill that scans an iOS or macOS project for common App Store rejection patterns before you submit
Skills for Apple development: SwiftUI, UIKit and Liquid Glass references, Swift 6 guides and a router for iOS 26+ tasks
A skill that builds in-app screen and element capture for a SwiftUI app and loops it across every locale for the App Store
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| Swift Concurrency Pro (this entry) | no | 577 | |
| Swift Concurrency Agent Skill | no | 1,694 | a different Swift concurrency skill by another author with its own set of reference files |
| SwiftUI Pro | no | 6,395 | same author, but SwiftUI interface review rather than concurrency |
README in short
The README explains that the skill helps Claude Code, Codex, Cursor and Gemini write concurrent Swift and shows the install routes: the plugin marketplace for Claude Code and `npx skills` for the rest. It then describes invoking by name and in natural language, the reasons for building the skill and the rules for contributors: keep it short, do not repeat what models know, and use the MIT license.
README badge
Original SKILL.md
---
name: swift-concurrency-pro
description: Reviews Swift code for concurrency correctness, modern API usage, and common async/await pitfalls. Use when reading, writing, or reviewing Swift concurrency code.
license: MIT
metadata:
author: Paul Hudson
version: "1.0"
---
Review Swift concurrency code for correctness, modern API usage, and adherence to project conventions. Report only genuine problems - do not nitpick or invent issues.
Review process:
1. Scan for known-dangerous patterns using `references/hotspots.md` to prioritize what to inspect.
1. Check for recent Swift 6.2 concurrency behavior using `references/new-features.md`.
1. Validate actor usage for reentrancy and isolation correctness using `references/actors.md`.
1. Ensure structured concurrency is preferred over unstructured where appropriate using `references/structured.md`.
1. Check unstructured task usage for correctness using `references/unstructured.md`.
1. Verify cancellation is handled correctly using `references/cancellation.md`.
1. Validate async stream and continuation usage using `references/async-streams.md`.
1. Check bridging code between sync and async worlds using `references/bridging.md`.
1. Review any legacy concurrency migrations using `references/interop.md`.
1. Cross-check against common failure modes using `references/bug-patterns.md`.
1. If the project has strict-concurrency errors, map diagnostics to fixes using `references/diagnostics.md`.
1. If reviewing tests, check async test patterns using `references/testing.md`.
If doing a partial review, load only the relevant reference files.
## Core Instructions
- Target Swift 6.2 or later with strict concurrency checking.
- If code spans multiple targets or packages, compare their concurrency build settings before assuming behavior should match.
- Prefer structured concurrency (task groups) over unstructured (`Task {}`).
- Prefer Swift concurrency over Grand Central Dispatch for new code. GCD is still acceptable in low-level code, framework interop, or performance-critical synchronous work where queues and locks are the right tool – don't flag these as errors.
- If an API offers both `async`/`await` and closure-based variants, always prefer `async`/`await`.
- Do not introduce third-party concurrency frameworks without asking first.
- Do not suggest `@unchecked Sendable` to fix compiler errors. It silences the diagnostic without fixing the underlying race. Prefer actors, value types, or `sending` parameters instead. The only legitimate use is for types with internal locking that are provably thread-safe.