Swift Concurrency Pro
A Swift concurrency code-review skill by Paul Hudson that targets the async/await and actor mistakes LLMs actually make.
Pure reference-documentation skill: no scripts, no network calls, no file writes or external side effects; near-minimal privilege. MIT license and clear author/repository attribution; fully auditable source. Deductions: publisher not verified (no deduction for that alone per rules, but rollback/install-change notes only partially covered), and openai.yaml sets allow_implicit_invocation: true, removing an explicit user-confirmation gate.
Instructions are self-consistent across SKILL.md and references (reentrancy and @unchecked Sendable guidance cross-referenced consistently); all 12 referenced files match the declared workflow. Static cap of 10 applies: no test suite, no CI execution evidence, no runnable key path; failure-feedback quality depends on the executing LLM, not the skill itself.
Trigger description is clear (use when reading/writing/reviewing Swift concurrency code), audience and boundaries explicit (does not reteach LLM fundamentals, no third-party frameworks), partial review supported. Deductions: implicit invocation may cause false triggers on any Swift contact; no Chinese-language support statement. Purely local docs with no overseas-service dependency, so reachability is fine.
Well-layered docs: concise SKILL.md respecting token budgets, 12 progressive-disclosure reference files, README with install, usage, contributing, and license; author and maintenance responsibility clear (Paul Hudson, active maintainer). Deductions: version is only "1.0" with no changelog, limited known-limitations disclosure (no stated fallback for pre-6.2 projects), no troubleshooting section.
Output format is well defined (per-file, line numbers, rule names, before/after diffs, prioritized summary); examples are concrete and usable; clear marginal value targeting LLM-specific concurrency mistakes (reentrancy, double-resume, etc.). Static cap of 7: no verified real-project review output; correctness of Swift 6.2 behavior claims unverified by execution; benefit must be confirmed in use.
Primary material is auditable: reference files contain checkable code examples and external links (massicotte.org, Apple APIs), with facts and recommendations reasonably separated. Capped at 5: no test reproduction, no third-party execution evidence; key claims about Swift 6.2 behavior are supported only by the author's own articles, without independent corroboration.
- This is a static source-only review; no skill instructions were executed and confidence is low.
- openai.yaml enables implicit invocation, which may consume tokens when not needed; disable it if you want explicit control.
- The skill targets Swift 6.2 strict concurrency; advice may not fit older projects — verify your target environment.
- No test suite or changelog; reference correctness is not independently execution-verified, so review findings still need human confirmation.
- Publisher is unverified in the FollowSkills registry; identity is treated as unknown, not as a deduction or suspicion.
What does this skill do, and when should you use it?
Swift Concurrency Pro is an Agent Skill for AI coding assistants that reviews Swift concurrency code for correctness, modern API usage, and common async/await pitfalls. It was written by Paul Hudson of Hacking with Swift and targets projects on Swift 6.2 or later with strict concurrency checking. Rather than re-teaching fundamentals the model already knows, it focuses on the mistakes LLMs genuinely make and on Swift 6.2 features they were not trained on. Findings are organized by file with line numbers, the violated rule, before/after code fixes, and a prioritized summary.
The skill walks the model through a fixed twelve-step review process: it scans for known-dangerous patterns via references/hotspots.md, then checks Swift 6.2 behavior, actor reentrancy and isolation, preference for structured concurrency, unstructured task usage, cancellation handling, AsyncStream and continuations, sync/async bridging, legacy GCD/interop migrations, common bug patterns, strict-concurrency compiler diagnostics, and async test patterns. Each step maps to a reference file, loaded selectively for partial reviews. Output is grouped by file, citing lines, the rule violated, before/after fixes, and ends with a prioritized summary of the most impactful changes.
- iOS/macOS developers on Swift 6.2 strict concurrency who want an AI to catch actor reentrancy and isolation bugs before commit
- Teams migrating GCD- or completion-handler-based codebases to async/await and task groups, needing migration correctness checks
- Engineers writing async Swift tests who want validation of Swift Testing patterns and avoidance of timing-based tests
- Code reviewers checking PRs for Task {} misuse in loops and lost cancellation propagation
- Developers needing strict-concurrency compiler errors mapped to concrete fixes
What are this skill's strengths and limitations?
- Authored by a leading Swift concurrency expert, with rules targeting real LLM mistakes rather than re-teaching basics
- Covers Swift 6.2 features (default actor isolation, @concurrent, Task.immediate, etc.) absent from most model training data
- Explicitly bans harmful advice like suggesting @unchecked Sendable to silence diagnostics; prefers actors, value types, and sending parameters
- Disciplined output format: file-grouped findings, line numbers, before/after diffs, prioritized summary
- MIT licensed — commercial use, modification, and distribution permitted
- Designed for Swift 6.2+ strict concurrency; applicability to older Swift projects is not stated
- The repo carries an iOS 26+ badge; suitability for earlier platform targets is unverified
- No test suite or independent evaluation in the source material evidencing review quality
- Review-only: it does not generate code or run the compiler, so fixes still need human verification
How do you install this skill?
In Claude Code: run /plugin marketplace add twostraws/Swift-Concurrency-Agent-Skill, then /plugin install swift-concurrency-pro@swift-concurrency-agent-skill. For Codex, Gemini, Cursor and others: run npx skills add https://github.com/twostraws/swift-concurrency-agent-skill --skill swift-concurrency-pro (requires Node.js — install via brew install node; if that fails, install Homebrew first). Alternatively, clone the whole repository and install it however you like. Xcode users can follow the author's installation video.
How do you use this skill?
Trigger a full review with /swift-concurrency-pro in Claude Code or $swift-concurrency-pro in Codex; append instructions for a partial review, e.g. '/swift-concurrency-pro Make sure my project takes full advantage of Swift concurrency'. Natural language also works: 'Use the Swift Concurrency Pro skill to look for potential concurrency problems in this project.' For partial reviews, the skill loads only the relevant reference files.
How does this skill compare with similar options?
The author also ships sibling skills — SwiftUI Pro, SwiftData Pro, and Swift Testing Pro — collected under the Swift Agent Skills repository; this skill is scoped specifically to Swift concurrency.