Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Swift Concurrency Patterns · rshankras | DecimalAI

rshankras/concurrency-patterns

SkillScore96Maintained

Swift concurrency patterns including Swift 6.2 approachable concurrency, structured concurrency, actors, continuations, and migration. Use when reviewing or building async code, fixing data race errors, or migrating to Swift 6.

codingby rshankras

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/rshankras-concurrency-patterns/SKILL.md

decimalai skills pull rshankras-concurrency-patterns --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/rshankras-concurrency-patterns/SKILL.md https://app.decimal.ai/s/rshankras-concurrency-patterns/SKILL.md

Raw file: /s/rshankras-concurrency-patterns/SKILL.md ↗ · machine-readable summary at /s/rshankras-concurrency-patterns.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

24 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 18d ago

Yes — +4% lift · at higher cost+60% tokens0% turns96% of whole cases pass with skill (23/24)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-02	✗→✓	▲ Improved	-3%	0%
case-01	✓→✓	＝ Same ✓	52%	0%
case-03	✓→✓	＝ Same ✓	65%	0%
case-04	✓→✓	＝ Same ✓	53%	0%
case-06	✓→✓	＝ Same ✓	88%	0%

Showing 5 of 24 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/3/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

rshankras / claude-code-apple-skills

skills/swift/concurrency-patterns/SKILL.md

View on GitHub ↗

License MITImported 8/3/2026Version v1

Skill contents

SKILL.md

Swift Concurrency Patterns

Comprehensive guide for Swift concurrency covering async/await, structured concurrency, actors, and the Swift 6.2 "Approachable Concurrency" features. Focuses on patterns that prevent data races and common mistakes that cause crashes.

When This Skill Activates

User has data race errors or actor isolation compiler errors
User is migrating to Swift 6 strict concurrency
User asks about async/await, actors, Sendable, TaskGroup, or MainActor
User needs to bridge legacy completion-handler APIs to async/await
User is working with Swift 6.2 features (@concurrent, isolated conformances)
User has concurrency bugs (actor reentrancy, task cancellation, UI freezes)

Decision Tree

What concurrency problem are you solving?
│
├─ Swift 6 compiler errors / migration
│  └─ migration-guide.md
│
├─ Swift 6.2 new features (@concurrent, isolated conformances)
│  └─ swift62-concurrency.md
│
├─ Running work in parallel (async let, TaskGroup)
│  └─ structured-concurrency.md
│
├─ Thread safety for shared mutable state
│  └─ actors-and-isolation.md
│
├─ Bridging old APIs (delegates, callbacks) to async/await
│  └─ continuations-bridging.md
│
├─ Hangs, slow parallelism, thread-pool problems, profiling
│  └─ concurrency-internals.md
│
└─ General async/await patterns
   └─ See macos/coding-best-practices/modern-concurrency.md for basics

Quick Reference

| Pattern | When to Use | Reference | |---------|-------------|-----------| | async let | Fixed number of parallel operations | structured-concurrency.md | | withTaskGroup | Dynamic number of parallel operations | structured-concurrency.md | | withDiscardingTaskGroup | Fire-and-forget parallel operations | structured-concurrency.md | | .task { } modifier | Load data when view appears | structured-concurrency.md | | .task(id:) modifier | Re-load when a value changes | structured-concurrency.md | | actor | Shared mutable state protection | actors-and-isolation.md | | @MainActor | UI-bound state and updates | actors-and-isolation.md | | @concurrent | Explicitly offload to background (6.2) | swift62-concurrency.md | | Isolated conformances | @MainActor type conforming to protocol (6.2) | swift62-concurrency.md | | withCheckedContinuation | Bridge callback API to async | continuations-bridging.md | | AsyncStream | Bridge delegate/notification API to async sequence | continuations-bridging.md | | @TaskLocal | Context (IDs, tracing) down the task tree | structured-concurrency.md | | Atomic / Mutex | Sendable wrappers for synchronous hot paths (Swift 6) | actors-and-isolation.md | | Custom actor executors | Bridge existing DispatchSerialQueue synchronization | concurrency-internals.md | | Swift Concurrency Instrument | Diagnose hangs, actor contention, continuation leaks | concurrency-internals.md | | Strict concurrency migration | Incremental Swift 6 adoption | migration-guide.md |

Process

1. Identify the Problem

Read the user's code or error messages to determine:

Is this a compiler error (strict concurrency) or a runtime issue (data race, crash)?
What Swift version and concurrency checking level are they using?
Are they migrating existing code or writing new code?

2. Load Relevant Reference Files

Based on the problem, read from this directory:

swift62-concurrency.md — Swift 6.2 approachable concurrency features, Apple's adoption doctrine, Swift 6.3/6.4 additions
structured-concurrency.md — async let, TaskGroup, .task modifier lifecycle, task-locals, cancellation semantics
actors-and-isolation.md — Actor patterns, reentrancy, @MainActor, Sendable, Atomic/Mutex
concurrency-internals.md — cooperative pool, unsafe primitives, actor scheduling, Swift Concurrency Instrument
continuations-bridging.md — withCheckedContinuation, AsyncStream, built-in async sequences, legacy bridging
migration-guide.md — Incremental Swift 6 strict concurrency adoption (WWDC24 doctrine)

3. Review Checklist

] No blocking calls on @MainActor (use await for long operations)
] Shared mutable state protected by an actor (not locks or DispatchQueue)
] Sendable conformance correct for types crossing isolation boundaries
] Task cancellation handled (check Task.isCancelled or Task.checkCancellation())
] No unstructured Task {} where structured concurrency (.task, TaskGroup) would work
] Actor reentrancy considered at suspension points
] withCheckedContinuation called exactly once (not zero, not twice)
] .task(id:) used instead of manual onChange + cancel patterns

4. Cross-Reference

For async/await basics and actor fundamentals, see macos/coding-best-practices/modern-concurrency.md
For networking concurrency patterns, see generators/networking-layer/networking-patterns.md
For SwiftData concurrency (@ModelActor), see macos/swiftdata-architecture/repository-pattern.md
For auth token refresh with actors, see generators/auth-flow/auth-patterns.md

References

Swift Concurrency
Migrating to Swift 6
Local captured doc (optional): ~/Downloads/docs/Swift-Concurrency-Updates.md — read if present; skip silently if absent.

Want to see if rshankras/concurrency-patterns would activate on your phrasing? Try it before you install — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/18/2026, 01:50 UTC · 24 cases

Lift

+4%

96% vs 92%

Agent turns

1.0 vs 1.0

Tokens

+60%

2,833.96 vs 1,767.96

fail → pass · 1pass → pass · 22fail → fail · 1

Per-case results (24)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-01 In a Swift 6 application, I am processing a batch of images where each image upload runs concurrently and returns no output value. I want to spawn subtasks dynamically without keeping their return values or task handles in memory. I am tempted to just create unstructured Task instances inside a loop or use standard withTaskGroup and accumulate Void results. What structured concurrency API should I use, and what reference file contains its detailed guide?	pass→pass	8,263	5,046	-39%	1	1	0%	1,496	2,271	+52%	0	0	—
case-02 In a Swift 6.2 iOS codebase, I have a method on a @MainActor view model that calculates heavy statistical data. To avoid UI freezing, I am considering wrapping the work inside Task.detached. Is there a Swift 6.2 language attribute designed specifically to explicitly mark a function to run off the main thread on a background thread pool, and which file documents this?	fail→pass	15,037	5,639	-62%	1	1	0%	2,502	2,419	-3%	0	0	—
case-03 In a SwiftUI view, I need to fetch remote user preferences whenever the active userID property changes. A colleague suggested attaching .onChange(of: userID) and manually canceling and creating a new Task. What is the recommended SwiftUI view modifier for re-running an async data task whenever a key value changes, and which guide file discusses it?	pass→pass	8,842	4,960	-44%	1	1	0%	1,404	2,315	+65%	0	0	—
case-04 I have a high-frequency performance-critical counter in a Swift 6 app that is accessed synchronously from multiple threads. I am tempted to turn the class into an actor and make caller functions async. However, latency requirements prohibit await context switches. What Synchronization primitive provided in Swift 6 allows thread-safe synchronous mutation without converting the type to an actor, and where is it documented?	pass→pass	9,781	8,518	-13%	1	1	0%	1,877	2,874	+53%	0	0	—
case-05 I have a legacy Swift closure-based method fetchUser(id: completion: @escaping (Result<User, Error>) -> Void). I want to wrap this in an async function. Someone suggested wrapping it in an unstructured Task block. What standard Swift concurrency construct should be used to suspend until the callback fires, and which file covers this?	fail→fail	8,410	5,531	-34%	1	1	0%	1,459	2,433	+67%	0	0	—
case-06 I am writing a location manager wrapper in Swift that receives stream updates via CLLocationManagerDelegate. I want callers to iterate over location updates using an async sequence loop. What standard Swift type converts delegate callbacks into an async sequence, and which doc file covers it?	pass→pass	6,417	3,333	-48%	1	1	0%	1,110	2,086	+88%	0	0	—
case-07 In a Swift server application, I need to pass a trace request ID down through nested subtasks without explicitly passing arguments through every function parameter. Should I use global singleton state or thread-local storage? What Swift concurrency attribute attaches metadata down the task tree, and which guide file details this?	pass→pass	9,806	4,880	-50%	1	1	0%	1,576	2,116	+34%	0	0	—
case-08 In Swift 6.2, I have a @MainActor annotated class that needs to conform to a protocol whose requirements are nonisolated. Previously, this caused strict concurrency actor isolation compiler errors. What Swift 6.2 feature allows a @MainActor type to conform to such protocols cleanly, and which reference file documents it?	pass→pass	10,716	5,057	-53%	1	1	0%	1,824	2,270	+24%	0	0	—
case-09 In a Swift function, I need to download exactly two independent assets—a profile image and a cover image—in parallel and await both results before updating the UI. Should I create a full TaskGroup or use a lighter structured concurrency construct? What construct is best suited for a fixed number of parallel operations, and which file documents it?	pass→pass	7,822	5,401	-31%	1	1	0%	1,354	2,334	+72%	0	0	—
case-10 I need to fetch user profiles for an array of 50 user IDs concurrently in Swift and collect all returned UserProfile objects into an array. Should I use async let in a loop or another structured concurrency pattern? What construct manages dynamic parallel operations that return results, and which file covers it?	pass→pass	10,033	7,268	-28%	1	1	0%	1,772	2,673	+51%	0	0	—
case-11 I am refactoring a legacy C/Swift engine that relies on a specific DispatchSerialQueue for serial execution. I want to expose an actor interface without introducing runtime thread-hopping between Swift actor execution and the existing queue. What advanced actor feature allows an actor to execute on an existing DispatchSerialQueue, and which file documents it?	pass→pass	6,716	5,656	-16%	1	1	0%	1,098	2,362	+115%	0	0	—
case-12 My iOS app experiences micro-hangs and thread pool contention. I need to inspect actor task scheduling, check for continuation leaks, and diagnose hangs. Which Xcode profiling instrument is specifically designed for analyzing Swift Concurrency runtime issues, and which reference file covers it?	pass→pass	8,338	4,880	-41%	1	1	0%	1,366	2,174	+59%	0	0	—
case-13 Our team is migrating a large iOS codebase to Swift 6 strict concurrency mode. Compiler warnings are overwhelming if enabled all at once across the entire project. What approach should be followed for adoption, and which file in the guide details this process?	pass→pass	10,511	9,504	-10%	1	1	0%	1,801	2,867	+59%	0	0	—
case-14 In a Swift library, I have a shared cache object storing mutable state that will be accessed concurrently across multiple background threads. Instead of manually handling locking with NSLock or DispatchQueue, what fundamental language construct should be used for thread-safe shared mutable state, and which guide file details its isolation mechanics?	pass→pass	5,751	5,987	+4%	1	1	0%	1,004	1,963	+96%	0	0	—
case-15 In an iOS application, multiple concurrent HTTP requests may receive a 401 Unauthorized response simultaneously and trigger an auth token refresh. I am tempted to spawn independent network requests for each failure or use a boolean flag with sleep loops. How should an actor manage in-flight token refresh requests so that multiple concurrent callers await the same single network operation?	pass→pass	17,651	16,648	-6%	1	1	0%	3,005	4,201	+40%	0	0	—
case-16 I need to perform large background database imports in a SwiftData app without blocking the main UI thread or causing data races on ModelContext. A team member suggested passing the main @MainActor ModelContext into a Task.detached block. What macro should be used to create a background worker initialized with a ModelContainer that manages its own isolated context?	pass→pass	8,906	8,124	-9%	1	1	0%	1,628	2,893	+78%	0	0	—
case-17 In Swift 6, I am passing a non-Sendable class instance from a @MainActor context into a background task. The compiler throws a strict concurrency error that non-Sendable data cannot cross isolation boundaries, even though the caller completely relinquishes reference to the instance after sending. Without marking the class Sendable or @unchecked Sendable, what Swift 6 keyword explicitly transfers region ownership across isolation boundaries?	pass→pass	8,615	5,577	-35%	1	1	0%	1,508	2,422	+61%	0	0	—
case-18 In Swift 6, I have a @MainActor view model class conforming to a non-async protocol requirement like CustomStringConvertible. The compiler errors because description is called from nonisolated contexts. Someone suggested marking the entire class @unchecked Sendable. What keyword should be applied to the description property to explicitly opt it out of main actor isolation?	pass→pass	7,493	5,790	-23%	1	1	0%	1,221	2,368	+94%	0	0	—
case-19 In a Swift iOS app using MVVM, I have a ViewModel class whose properties directly drive SwiftUI view rendering. Which annotation ensures all updates and accesses to this model occur exclusively on the main thread, and which guide file covers it?	pass→pass	5,377	4,047	-25%	1	1	0%	855	2,059	+141%	0	0	—
case-20 When writing a withCheckedContinuation wrapper in Swift to convert a legacy completion block, how many times must the provided continuation's resume method be called during execution?	pass→pass	4,494	4,425	-2%	1	1	0%	676	2,117	+213%	0	0	—
case-21 Inside a long-running cooperative loop running inside a Swift Task, how should the code periodically check if the parent task has been canceled and throw a CancellationError?	pass→pass	8,838	6,809	-23%	1	1	0%	1,478	2,506	+70%	0	0	—
case-22 How do I implement a complete SwiftData offline repository with SwiftData ModelContainer persistence configuration, schema migration, and mock preview data for unit testing?	pass→pass	19,395	22,112	+14%	1	1	0%	4,212	6,025	+43%	0	0	—
case-23 How do I construct a custom URLRequest builder with URLComponents, custom header dictionaries, and multipart form body encoding in Swift?	pass→pass	15,276	21,058	+38%	1	1	0%	3,512	6,237	+78%	0	0	—
case-24 How do I securely store and retrieve OAuth refresh tokens in the iOS Keychain using SecItemAdd and SecItemCopyMatching APIs?	pass→pass	14,466	13,008	-10%	1	1	0%	2,693	4,030	+50%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 24 cases were attempted. The headline lift of +4 percentage points is the difference between those two pass rates over the 24 comparable cases.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 91.7%
Pass rate with the skill: 95.8%
Cases attempted: 24
Cases counted toward lift: 24
Cases that regressed: 0
Skill version measured: v1
Run completed: 8/18/2026, 01:50 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-02

Prompt

In a Swift 6.2 iOS codebase, I have a method on a @MainActor view model that calculates heavy statistical data. To avoid UI freezing, I am considering wrapping the work inside Task.detached. Is there a Swift 6.2 language attribute designed specifically to explicitly mark a function to run off the main thread on a background thread pool, and which file documents this?

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signals1 of 4 complete

BenchmarkPass rate WITH skill on a verified run96

Live evalNeeds ≥20 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+64% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

Backed by 1 of 4 signals — each added signal makes the score more robust.

Verified on gemini-3.6-flash · re-tested 18 days ago

Other measured skills in the registry, with their headline benchmark lift.