Claude Skill

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

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Download nimadorostkar-claude-skills-collection-skills_languages_swift-1691932.zip · 1 KB

Install

skills CLI npx skills add https://github.com/nimadorostkar/Claude-Skills-collection/tree/main/skills/languages/swift
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install nimadorostkar-claude-skills-collection@llmmart
Git 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, 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:

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.
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.

No comments yet.

Reviews (0)

No reviews yet.