The best Swift concurrency skills for AI agents

Swift 6 turned data races into compile errors. Swift 6.2 then changed what the compiler assumes before it starts checking — and that is the part that catches agents out. Ask a model to clear an actor-isolation error from its own general knowledge and you get one of two failures: Swift 5 reflexes (DispatchQueue.main.async, a lock, an @unchecked Sendable slapped on to make the message disappear), or advice that was correct under 6.0 and is now wrong, because async functions no longer hop off the calling actor by default.

The thing worth knowing before you install any Swift concurrency skill: the good ones don't open with patterns. They open with an instruction to go read the project's build settings. And affaan-m's swift-concurrency-6-2 is blunt enough to put that dependency on its own sample code — the example is safe with approachable concurrency turned on and a genuine data race without it. Same code, two build flags, opposite verdicts.

Top picks

skill	publisher	license	verdict	updated
swift-concurrency	AvdLee	MIT	Install first	2026-05-28
swift-concurrency-6-2	affaan-m	MIT	Clearest account of the 6.2 model	2026-07-27
swift-concurrency-6-2	xu-xiang	MIT	Redundant if you have the above	2026-03-05
concurrency-patterns	rshankras	MIT	Take it with its sibling	2026-07-24
swift-concurrency-updates	rshankras	MIT	The 6.2 half of that pair	2026-07-24
modern-swift	johnrogers	MIT	Failure list, not a migration guide	2026-01-18
swift-code-review	existential-birds	Apache-2.0	Review side	2026-07-21

AvdLee's swift-concurrency: the one that refuses to guess

AvdLee's swift-concurrency opens by making the agent read Package.swift or the .pbxproj to establish language mode, strict-concurrency level, default isolation and upcoming features — always, not only during a migration — and it warns that the swift-tools-version comment is not a reliable proxy for the language mode. It carries a settings table mapping the SwiftPM API to the matching Xcode build-setting keys, and a diagnostic table pairing each compiler message with a first check and a smallest safe fix. If the settings are unknown, it tells the agent to stop and ask.

The escape hatches are gated rather than banned: @preconcurrency, @unchecked Sendable and nonisolated(unsafe) each require a documented safety invariant and a removal plan. Two limits. Depth lives in fourteen references/*.md files, so vendoring the single top file gets you the triage tables and not much else. And the footer points at the author's concurrency course, though the instructions do tell the agent to use those links sparingly.

affaan-m's swift-concurrency-6-2: the clearest account of what 6.2 changed

affaan-m's swift-concurrency-6-2 teaches the new model through before/after pairs: the same StickerModel that fails under 6.1 and compiles under 6.2, isolated conformances written as extension Type: @MainActor Protocol, static shared singletons that need main-actor protection, and a four-step recipe for @concurrent — mark the type nonisolated, add the attribute, make it async, await at the call sites. Its best moment is a warning it puts on its own example: without SE-0466 and SE-0461 enabled, that code has a data race.

The caveat is what it doesn't do. Its migration steps tell you where those settings live and its examples name the ones they depend on, but nothing in it reads the project's current settings before advising — so an agent holding only this will cheerfully apply 6.2 idioms to a project that has none of them switched on. Pair it with something that checks first.

rshankras's concurrency-patterns: install the pair, not the half

rshankras's concurrency-patterns is a router. A decision tree sends the agent from a symptom — compiler error, hang, bridging a delegate — to one reference file, and the review checklist is sharper than most: shared state behind an actor rather than a queue, reentrancy considered at every suspension point, and withCheckedContinuation called exactly once, not zero times and not twice. Its sibling swift-concurrency-updates covers only the 6.2 deltas and says so, pointing back to the general patterns for everything else.

Both bodies declare their own shelf life in frontmatter — a last_verified date of 2026-07-16, a review_by date, an os_version line — which is rare and worth rewarding. The catch: they cross-reference sibling directories elsewhere in the repository, so the pair expects the whole set, not two files.

johnrogers's modern-swift: a short list of the bugs you can't see

johnrogers's modern-swift is mistakes-first and mercifully brief. The entry that earns the install is actor reentrancy: an await inside an actor method gives up isolation, another task can mutate state across that suspension point, and the instruction is to design the method assuming state changed while it waited. It also separates checking Task.isCancelled from calling Task.checkCancellation() — a distinction that quietly decides whether cancellation does anything at all.

The trade-off is coverage. The top-level file is thin on the 6.2 specifics its title implies, and it leans hard on reference files it tells the agent to load whenever there is even a small chance they matter. Use it as a list of failure modes, not as a migration plan.

existential-birds' swift-code-review: catch it at review time

Authoring skills fix the code in front of them; existential-birds' swift-code-review is built to fail a review before it emits anything. Its gates run in sequence and each carries a stated pass condition: name the concrete Swift language version or mode before giving any version-gated advice, read the full enclosing type or member rather than the diff hunk, and declare which checklist areas were applied or why they are not applicable. Findings come out as [FILE:LINE] with a severity, which makes them arguable.

Its checklist lines are opinions, not platitudes — actors must have mutable state to protect, @unchecked Sendable must be backed by real synchronisation. One dependency: the verification gates live in a separate review-protocol skill in the same repository, and without it you lose the pre-report check.

Which Swift concurrency skill should you install first?

AvdLee's, and it isn't close. The first mistake an agent makes on Swift concurrency is not a wrong pattern — it's a wrong assumption about the project, and every downstream fix inherits it. A skill that forces the build-settings read before the diagnosis turns the whole class of "correct advice, wrong compiler mode" errors into a question the agent asks you instead of a change it makes.

Add affaan-m's next if the project is heading to 6.2, because that document explains the new defaults better than any diagnostic table does. Take rshankras's pair if you want a routed reference library rather than a single file. Add johnrogers' for the reentrancy and cancellation traps. Put existential-birds' on the review side, where a second opinion costs nothing.

The name on a skill is only its topic

Skills are community-published and their names are not namespaced, so one name routinely covers different documents — and sometimes the very same document. A skill called swift-concurrency-6-2 can be affaan-m's English text or xu-xiang's, which is that document rendered into Chinese: same section order, same StickerModel example, same design-decisions table, translated. Neither is a fake. But install both expecting a second opinion and you have installed one opinion twice.

The tell is in the body, and occasionally it is stated outright — a companion skill in the same repository, swift-actor-persistence, names its origin in its own frontmatter. Names aren't stable inside a single repository either: rshankras's 6.2 skill is filed under one name and declares a different one in its frontmatter.

So run two checks before you vendor anything. First, read the opening screen of the body and confirm it gives instructions rather than exposition. mosif16's Swift 6 report is a genuinely interesting analysis of ownership, noncopyable types and region-based isolation — and it has an executive summary, numbered sections, footnote markers and a closing table of sources. Handed to an agent, that is prose to summarise, not a procedure to follow. Second, check the licence: that same document ships without one, which is its own reason to think twice.

What to hand your agent

The failure this closes off is an agent that confidently applies the wrong era of Swift concurrency to your project — Swift 5 reflexes, or 6.0-correct advice under a 6.2 compiler — and then reaches for @unchecked Sendable when the compiler objects. What shuts it down is not a larger pattern library. It is the ordering: the project's language mode, strict-concurrency level and default isolation get established before anything is proposed, and every escape hatch costs a written invariant and a removal plan.

Install the first two and your agent stops guessing which Swift it is writing. That is most of the problem.