Engineering SwiftSwiftUIiOS

Swift Expert

Swift/SwiftUI development: protocol-oriented programming, concurrency with async/await, Combine, UIKit interop, App Store submission, and iOS/macOS patterns.

A Swift expert covering protocol-oriented design, Swift concurrency (actors, async/await, TaskGroup), SwiftUI state management with @Observable, and UIKit interop via UIViewRepresentable. Guides App Store submission, handles provisioning profile issues, and optimizes app launch time and memory on constrained iOS devices.

Added Mar 20, 2026

$npx skills add johnefemer/skillfish --skill swift-expert

Capabilities Real Examples Get Started Models & Context Works Great With

What This Skill Can Do

Concrete capabilities you get when you install this skill.

Design protocol-oriented abstractions for testable, composable iOS code

Implement Swift concurrency with actors, async/await, and structured TaskGroup

Build SwiftUI views with @Observable, @Environment, and custom PreferenceKeys

Bridge UIKit and SwiftUI with UIViewRepresentable and UIHostingController

Diagnose and fix memory leaks with Xcode Instruments (Allocations, Leaks)

Navigate App Store submission, provisioning profiles, and TestFlight setup

Real Conversations

See how the Swift Expert skill responds to actual requests. These are representative examples of what your AI agent will produce.

You

I need a thread-safe in-memory cache for my iOS app that multiple Tasks can read from concurrently. Should I use NSCache, a dictionary with locks, or something else?

Agent

Use a Swift actor for the cleanest thread-safe cache. Actors serialize access automatically — no locks, no data races:

actor ImageCache {
    private var storage: [URL: UIImage] = [:]
    private let maxSize: Int

    init(maxSize: Int = 200) {
        self.maxSize = maxSize
    }

    func get(_ url: URL) -> UIImage? {
        storage[url]
    }

    func set(_ image: UIImage, for url: URL) {
        if storage.count >= maxSize {
            // Simple eviction: remove first entry
            storage.removeValue(forKey: storage.keys.first!)
        }
        storage[url] = image
    }
}

// Usage from any async context
let cache = ImageCache()

func loadImage(url: URL) async throws -> UIImage {
    if let cached = await cache.get(url) { return cached }
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = UIImage(data: data)!
    await cache.set(image, for: url)
    return image
}

When to use NSCache instead: NSCache is better when you need automatic memory-pressure eviction (it clears itself when iOS is low on memory). The actor pattern above doesn't do that. Combine both: store in NSCache and wrap it in an actor for async access.

When to avoid: Don't wrap the actor in a singleton — inject it as a dependency for testability.

You

I have a SwiftUI view that shows a list of items fetched from an API. After I call an async update function and the data changes in my ViewModel, the view doesn't refresh. What's wrong?

Agent

SwiftUI only re-renders when its observation system detects a change. If the view is stuck, one of these is the cause:

1. ViewModel not using @Observable (iOS 17+) or ObservableObject:

// ✅ iOS 17+ — use @Observable macro
@Observable
class ItemViewModel {
    var items: [Item] = [] // automatically tracked

    func fetchItems() async {
        let data = try? await api.fetchItems()
        // Must update on MainActor for UI
        await MainActor.run {
            items = data ?? []
        }
    }
}

// In the view:
@State private var viewModel = ItemViewModel()

2. Updating state off the main thread:

// ❌ This update happens on a background thread — undefined behavior in SwiftUI
func fetchItems() async {
    items = await api.fetchItems() // network task runs off main thread
}

// ✅ Two correct patterns:
@MainActor func fetchItems() async { ... } // whole function on main actor
// OR
await MainActor.run { self.items = result } // explicit hop

3. @ObservedObject vs @StateObject:

// ❌ @ObservedObject re-creates the VM on parent re-renders
@ObservedObject var vm = ItemViewModel()

// ✅ @StateObject (or @State with @Observable) is owned by the view
@StateObject var vm = ItemViewModel()

The most common fix: add @MainActor to the ViewModel class or to the fetch method, and switch to @Observable if on iOS 17+.

Get Started

How to install and use this skill in your preferred environment.

Skills are designed for AI coding agents (Claude Code, Cursor, Windsurf) and IDE-based workflows where the agent can read files, run scripts, and act on your codebase.

Models & Context

Which AI models and context windows work best with this skill.

Recommended Models

Claude Sonnet 4 or GPT-4o for Swift concurrency and SwiftUI. Verify iOS version-specific APIs (e.g., @Observable requires iOS 17) against Apple developer documentation.

Context Window

SKILL.md ~4KB. Fits comfortably in 32K context; large Xcode project refactors benefit from 64K+.

Pro tips for best results

1

Be specific

Include numbers — users, budget, RPS — so the skill can size the architecture.

2

Share constraints

Compliance needs, team size, and existing stack all improve the output.

3

Iterate

Start with a high-level design, then ask follow-ups for IaC, cost analysis, or security review.

4

Combine skills

Pair with companion skills below for end-to-end coverage.

Works Great With

These skills complement Swift Expert for end-to-end coverage. Install them together for better results.

Mobile Developer

Cross-platform mobile development: React Native and Flutter patterns, native bridge design, offline-first architecture, push notifications, and app store deployment.

React NativeFlutter

Senior SecOps

Application security, vulnerability management, compliance, and automation.

SecurityCompliance

TDD Guide

Test-driven development workflow with test generation and multi-framework support.

TDDTesting

$ skillfish add johnefemer/skillfish --all # install all skills at once

Ready to try Swift Expert?

Install the skill and start getting expert-level guidance in your workflow — any agent, any IDE.