swift
Use when writing Swift for iOS, macOS, or server-side. Covers value semantics, optionals, protocol-oriented design, structured concurrency with async/await and actors, and SwiftUI state management. Trigger on "migrate this completion handler to async/await", "sendable warnings un
Install
npx skills add https://github.com/nimadorostkar/Claude-Skills-collection/tree/main/skills/languages/swift
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install nimadorostkar-claude-skills-collection@llmmart
git clone https://github.com/nimadorostkar/Claude-Skills-collection.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole nimadorostkar/claude-skills-collection collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
Swift
Purpose
Write Swift that leans on value semantics and the concurrency model rather than fighting them: structs by default, actors for shared mutable state, and no force-unwrapping.
When to Use
- Writing Swift for Apple platforms or server-side Swift.
- Migrating callback or Combine code to async/await.
- Resolving data-race warnings under strict concurrency checking.
- Designing SwiftUI state and view models.
- Diagnosing retain cycles and memory growth.
Capabilities
- Value vs reference semantics and copy-on-write.
- Optional handling:
guard let, optional chaining,Resulttypes. - Protocol-oriented design with associated types and generics.
- Structured concurrency:
async let, task groups, actors,Sendable. - SwiftUI:
@State,@Observable, and unidirectional data flow.
Inputs
- Source target, Swift version, minimum deployment target.
- Concurrency checking level (minimal, targeted, complete).
Outputs
- Code free of force-unwraps and implicit unwrapped optionals.
- Concurrency that compiles cleanly under strict checking.
- View models with a single source of truth.
Workflow
- Prefer structs — Reach for a class only when identity or shared mutation is required.
- Eliminate optionals early — Unwrap once at the boundary with
guard; the rest of the function works with non-optionals. - Isolate mutable state — Any shared mutable state becomes an actor or is confined to the main actor.
- Model async explicitly — Replace completion handlers with
asyncfunctions; use task groups for concurrency. - Gate — Build with strict concurrency checking and treat warnings as errors.
Best Practices
!is a crash waiting for a user to find it. The only acceptable uses are IBOutlets and genuinely proven invariants with a comment.- Capture lists (
[weak self]) on every escaping closure that capturesselfin a class. - Mark types
Sendabledeliberately; suppressing the warning with@unchecked Sendablerequires a documented reason. - SwiftUI views are cheap and disposable — put logic in the model, not the view body.
- Prefer
async letfor a fixed set of concurrent calls; useTaskGroupwhen the count is dynamic. - Long-running work never runs on the main actor.
Examples
Actor-isolated cache with concurrent loading:
actor ImageCache {
private var cache: [URL: UIImage] = [:]
private var inFlight: [URL: Task<UIImage, Error>] = [:]
func image(for url: URL) async throws -> UIImage {
if let cached = cache[url] { return cached }
if let existing = inFlight[url] { return try await existing.value }
let task = Task<UIImage, Error> {
let (data, _) = try await URLSession.shared.data(from: url)
guard let image = UIImage(data: data) else { throw CacheError.decodeFailed(url) }
return image
}
inFlight[url] = task
defer { inFlight[url] = nil }
let image = try await task.value
cache[url] = image
return image
}
}
Notes
- The actor above deduplicates concurrent requests for the same URL — a common source of redundant network traffic in image-heavy screens.
- Strict concurrency checking is noisy on legacy code. Enable it target by target rather than repository-wide.
@Observable(iOS 17+) replacesObservableObjectand only invalidates views that actually read the changed property.
Files (claude-skills-collection)
-
SKILL.md 4 KB
--- name: swift description: Use when writing Swift for iOS, macOS, or server-side. Covers value semantics, optionals, protocol-oriented design, structured concurrency with async/await and actors, and SwiftUI state management. Trigger on "migrate this completion handler to async/await", "sendable warnings under strict concurrency", "retain cycle in my closure", "where should this state live". Do not use for app architecture, navigation, or App Store submission — see the ios skill. metadata: category: languages version: 1.0.0 tags: [swift, ios, concurrency, actors, swiftui] --- # Swift ## Purpose Write Swift that leans on value semantics and the concurrency model rather than fighting them: structs by default, actors for shared mutable state, and no force-unwrapping. ## When to Use - Writing Swift for Apple platforms or server-side Swift. - Migrating callback or Combine code to async/await. - Resolving data-race warnings under strict concurrency checking. - Designing SwiftUI state and view models. - Diagnosing retain cycles and memory growth. ## Capabilities - Value vs reference semantics and copy-on-write. - Optional handling: `guard let`, optional chaining, `Result` types. - Protocol-oriented design with associated types and generics. - Structured concurrency: `async let`, task groups, actors, `Sendable`. - SwiftUI: `@State`, `@Observable`, and unidirectional data flow. ## Inputs - Source target, Swift version, minimum deployment target. - Concurrency checking level (minimal, targeted, complete). ## Outputs - Code free of force-unwraps and implicit unwrapped optionals. - Concurrency that compiles cleanly under strict checking. - View models with a single source of truth. ## Workflow 1. **Prefer structs** — Reach for a class only when identity or shared mutation is required. 2. **Eliminate optionals early** — Unwrap once at the boundary with `guard`; the rest of the function works with non-optionals. 3. **Isolate mutable state** — Any shared mutable state becomes an actor or is confined to the main actor. 4. **Model async explicitly** — Replace completion handlers with `async` functions; use task groups for concurrency. 5. **Gate** — Build with strict concurrency checking and treat warnings as errors. ## Best Practices - `!` is a crash waiting for a user to find it. The only acceptable uses are IBOutlets and genuinely proven invariants with a comment. - Capture lists (`[weak self]`) on every escaping closure that captures `self` in a class. - Mark types `Sendable` deliberately; suppressing the warning with `@unchecked Sendable` requires a documented reason. - SwiftUI views are cheap and disposable — put logic in the model, not the view body. - Prefer `async let` for a fixed set of concurrent calls; use `TaskGroup` when the count is dynamic. - Long-running work never runs on the main actor. ## Examples **Actor-isolated cache with concurrent loading:** ```swift actor ImageCache { private var cache: [URL: UIImage] = [:] private var inFlight: [URL: Task<UIImage, Error>] = [:] func image(for url: URL) async throws -> UIImage { if let cached = cache[url] { return cached } if let existing = inFlight[url] { return try await existing.value } let task = Task<UIImage, Error> { let (data, _) = try await URLSession.shared.data(from: url) guard let image = UIImage(data: data) else { throw CacheError.decodeFailed(url) } return image } inFlight[url] = task defer { inFlight[url] = nil } let image = try await task.value cache[url] = image return image } } ``` ## Notes - The actor above deduplicates concurrent requests for the same URL — a common source of redundant network traffic in image-heavy screens. - Strict concurrency checking is noisy on legacy code. Enable it target by target rather than repository-wide. - `@Observable` (iOS 17+) replaces `ObservableObject` and only invalidates views that actually read the changed property.
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.