Swift Concurrency Pro
Have AI coding assistants review async/await, actor, and task-group code against Swift 6.2 strict concurrency, targeting the mistakes LLMs actually make.
This is a purely read-only code-review instruction skill: no external effects, no network calls, no dependency installation, no system modification — minimal risk surface; author attribution (Paul Hudson) and MIT license are explicit. Deducted because the publisher is unverified by the FollowSkills registry and the referenced files' contents are not present in the evidence, so data-flow and content integrity cannot be confirmed.
SKILL.md is internally self-consistent: 12 clearly structured review steps, uniform ${CLAUDE_SKILL_DIR} reference paths, a complete output-format example, and a sensible partial-review fallback. Deducted because the 12 referenced files are absent from the evidence, so key paths cannot be statically verified; failure feedback on abnormal input depends on LLM behavior with no controlled error modes.
Trigger conditions are clear (use when reading, writing, or reviewing Swift concurrency code), targeting Claude Code/Codex/Cursor/Gemini with documented install paths, natural-language triggering, and partial-review support. Deducted for missing declared non-fit boundaries (e.g., Swift 5 projects, non-Apple platforms), no mention of Chinese-language support; mainland-China reachability risk is low since the skill runs locally.
Good information architecture: a lean SKILL.md with progressive disclosure into reference files, respecting token budgets; author, version, and license metadata present; contribution guidelines clear. Deducted for no changelog, a bare '1.0' version with no update history, and maintenance responsibility resting on an individual without organizational governance commitments.
The value proposition is clear: it targets LLM-typical Swift concurrency mistakes (@unchecked Sendable abuse, reentrancy, Tasks in loops), the example output is directly usable, and it explicitly avoids re-teaching what LLMs already know to save tokens. Deducted because there is no execution evidence or third-party verification that actual review results are correct and complete; benefit claims rest mainly on the author's experience narrative.
Core rules (reentrancy example, task-group substitution) are technically sound and independently auditable, and the author's public Swift concurrency writings provide corroborating background. Deducted for no CI workflows, no committed test suites, no third-party execution evidence covering the skill's key paths, and invisible reference files — most claims are author assertions.
- This is a static review; no code was executed. The 12 reference files were not included in the evidence, so the actual quality of the core review logic cannot be verified.
- The publisher is unverified by the enterprise registry; author identity rests on repository self-description (Paul Hudson). Verify repository integrity before use.
- The skill explicitly targets Swift 6.2+ with strict concurrency checking; applicability to older Swift versions or non-Apple platforms is undeclared.
- No version history or changelog exists; Swift 6.2-specific advice may become stale as the compiler evolves — monitor repository updates.
- Review output is advisory and interpreted by an LLM; manual review is still required for critical code changes.
What does this skill do, and when should you use it?
Swift Concurrency Pro is an Agent Skill by Paul Hudson that reviews Swift code for concurrency correctness, modern API usage, and common async/await pitfalls. It targets Swift 6.2 or later with strict concurrency checking and ships twelve reference documents covering actor reentrancy, task groups, cancellation, AsyncStream, sync/async bridging, GCD migration, strict-concurrency diagnostics, and async testing. The skill deliberately reports only genuine problems and avoids re-teaching fundamentals LLMs already know, drawing on the author's Swift concurrency book and his Swift 6.x what's-new articles. The author runs Hacking with Swift, and the skill is MIT-licensed and open source.
On invocation it loads reference files from ${CLAUDE_SKILL_DIR}/references/ (hotspots, new-features, actors, structured, unstructured, cancellation, async-streams, bridging, interop, bug-patterns, diagnostics, testing) and scans code for known-dangerous concurrency patterns. It checks Swift 6.2 behavior changes (default actor isolation, isolated conformances, @concurrent, Task.immediate, etc.), validates actor reentrancy and isolation, verifies cancellation handling and AsyncStream/continuation usage, reviews sync-to-async bridging and legacy migration code, and maps strict-concurrency compiler diagnostics to fixes. Output is organized by file: each issue names the file and lines, the violated rule, and a before/after code fix, ending with a prioritized summary of the most impactful changes.
- Swift developers on projects with strict concurrency checking who want actor reentrancy or lost cancellation propagation surfaced
- Teams migrating legacy projects from GCD or completion handlers to async/await and task groups who need migration review
- Users adopting Swift 6.2 features like default actor isolation and @concurrent that AI assistants were not trained on
- Developers writing or reviewing async tests with Swift Testing who want recommended patterns enforced
- Anyone hitting strict-concurrency compiler errors who wants diagnostics mapped to real fixes instead of @unchecked Sendable hacks
What are this skill's strengths and limitations?
- Maintained by the author of a Swift concurrency book, with content grounded in first-party material
- Explicitly targets LLM concurrency mistakes, including Swift 6.2 features beyond model training data
- Avoids re-teaching fundamentals, keeping token costs down
- Disciplined output format: per-file findings, before/after fixes, and a prioritized summary
- MIT license permits commercial use, modification, and distribution; explicitly bans @unchecked Sendable as a race fix
- Targets Swift 6.2+ with strict concurrency checking; limited benefit for older Swift codebases
- The repository bundles 2 skills, so a full-repo install brings in unneeded content
- No standalone test suite or effectiveness evaluation data is provided in the source
- Reference files are written in English; the review language depends on the AI tool used
How do you install this skill?
Claude Code: add the marketplace then install: /plugin marketplace add twostraws/Swift-Concurrency-Agent-Skill, followed by /plugin install swift-concurrency-pro@swift-concurrency-agent-skill. Codex, Gemini, Cursor, and others: run npx skills add https://github.com/twostraws/swift-concurrency-agent-skill --skill swift-concurrency-pro (requires Node.js; on Mac install via brew install node). You can also clone the whole repository and install it manually; Xcode users can follow the author's install video. Note the repository bundles 2 skills — the npx command installs only this one via --skill swift-concurrency-pro.
How do you use this skill?
In Claude Code invoke with /swift-concurrency-pro; in Codex use $swift-concurrency-pro. Both accept extra instructions for a partial review, e.g. /swift-concurrency-pro Help me migrate this project to task groups. You can also trigger it with natural language such as "Use the Swift Concurrency Pro skill to look for potential concurrency problems in this project." The skill supports a [focus area] argument hint, and partial reviews load only the relevant reference files.
How does this skill compare with similar options?
The README positions this skill alongside the author's sibling skills SwiftUI Pro, SwiftData Pro, and Swift Testing Pro, and contrasts it with skills that dump all Swift concurrency advice ever — this one only includes rules with real impact. General-purpose AI assistants already know async/await, actors, and structured concurrency basics, but need this skill for Swift 6.2 features and common error patterns.