Swift Expert

by jeffallan1be15d8064f8MIT11K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 5 days ago

Builds iOS/macOS/watchOS/tvOS applications, implements SwiftUI views and state management, designs protocol-oriented architectures, handles async/await concurrency, implements actors for thread safety, and debugs Swift-specific issues. Use when building iOS/macOS applications with Swift 5.9+, SwiftUI, or async/await concurrency. Invoke for protocol-oriented programming, SwiftUI state management, actors, server-side Swift, UIKit integration, Combine, or Vapor.

Instructions onlySoftware Development

AI-generated overview

Guides Swift 5.9+ development for Apple platforms, covering SwiftUI, async/await, actors, protocols and testing.

What it does: Provides a structured workflow and reference guidance for building Swift applications on iOS, macOS, watchOS and tvOS. It covers SwiftUI views and state management, protocol-oriented architecture, async/await concurrency, actor isolation, memory and performance, and XCTest-based testing. It produces code patterns, protocol and model definitions, view implementations, tests, and architectural explanations.
When to use it: Use when implementing or debugging Swift 5.9+ code, especially SwiftUI interfaces, concurrency with async/await or actors, protocol-oriented designs, UIKit or Combine integration, or server-side Swift with Vapor.
Requirements: Requires a Swift 5.9+ toolchain and build tooling such as swift build and swift test. Ships reference documents only; no scripts are included.

Swift Expert

Core Workflow

Architecture Analysis - Identify platform targets, dependencies, design patterns
Design Protocols - Create protocol-first APIs with associated types
Implement - Write type-safe code with async/await and value semantics
Optimize - Profile with Instruments, ensure thread safety
Test - Write comprehensive tests with XCTest and async patterns

Validation checkpoints: After step 3, run swift build to verify compilation. After step 4, run swift build -warnings-as-errors to surface actor isolation and Sendable warnings. After step 5, run swift test and confirm all async tests pass.

Reference Guide

Load detailed guidance based on context:

Topic	Reference	Load When
SwiftUI	`references/swiftui-patterns.md`	Building views, state management, modifiers
Concurrency	`references/async-concurrency.md`	async/await, actors, structured concurrency
Protocols	`references/protocol-oriented.md`	Protocol design, generics, type erasure
Memory	`references/memory-performance.md`	ARC, weak/unowned, performance optimization
Testing	`references/testing-patterns.md`	XCTest, async tests, mocking strategies

Code Patterns

async/await — Correct vs. Incorrect

swift

// ✅ DO: async/await with structured error handlingfunc fetchUser(id: String) async throws -> User {    let url = URL(string: "https://api.example.com/users/\(id)")!    let (data, _) = try await URLSession.shared.data(from: url)    return try JSONDecoder().decode(User.self, from: data)}
// ❌ DON'T: mixing completion handlers with async contextfunc fetchUser(id: String) async throws -> User {    return try await withCheckedThrowingContinuation { continuation in        // Avoid wrapping existing async APIs this way when a native async version exists        legacyFetch(id: id) { result in            continuation.resume(with: result)        }    }}

// ✅ DO: async/await with structured error handlingfunc fetchUser(id: String) async throws -> User {    let url = URL(string: "https://api.example.com/users/\(id)")!    let (data, _) = try await URLSession.shared.data(from: url)    return try JSONDecoder().decode(User.self, from: data)}
// ❌ DON'T: mixing completion handlers with async contextfunc fetchUser(id: String) async throws -> User {    return try await withCheckedThrowingContinuation { continuation in        // Avoid wrapping existing async APIs this way when a native async version exists        legacyFetch(id: id) { result in            continuation.resume(with: result)        }    }}

SwiftUI State Management

swift

// ✅ DO: use @Observable (Swift 5.9+) for view models@Observablefinal class CounterViewModel {    var count = 0    func increment() { count += 1 }}
struct CounterView: View {    @State private var vm = CounterViewModel()
    var body: some View {        VStack {            Text("\(vm.count)")            Button("Increment", action: vm.increment)        }    }}
// ❌ DON'T: reach for ObservableObject/Published when @Observable sufficesclass LegacyViewModel: ObservableObject {    @Published var count = 0  // Unnecessary boilerplate in Swift 5.9+}

// ✅ DO: use @Observable (Swift 5.9+) for view models@Observablefinal class CounterViewModel {    var count = 0    func increment() { count += 1 }}
struct CounterView: View {    @State private var vm = CounterViewModel()
    var body: some View {        VStack {            Text("\(vm.count)")            Button("Increment", action: vm.increment)        }    }}
// ❌ DON'T: reach for ObservableObject/Published when @Observable sufficesclass LegacyViewModel: ObservableObject {    @Published var count = 0  // Unnecessary boilerplate in Swift 5.9+}

Protocol-Oriented Architecture

swift

// ✅ DO: define capability protocols with associated typesprotocol Repository<Entity> {    associatedtype Entity: Identifiable    func fetch(id: Entity.ID) async throws -> Entity    func save(_ entity: Entity) async throws}
struct UserRepository: Repository {    typealias Entity = User    func fetch(id: UUID) async throws -> User { /* … */ }    func save(_ user: User) async throws { /* … */ }}
// ❌ DON'T: use classes as base types when a protocol fitsclass BaseRepository {  // Avoid class inheritance for shared behavior    func fetch(id: UUID) async throws -> Any { fatalError("Override required") }}

// ✅ DO: define capability protocols with associated typesprotocol Repository<Entity> {    associatedtype Entity: Identifiable    func fetch(id: Entity.ID) async throws -> Entity    func save(_ entity: Entity) async throws}
struct UserRepository: Repository {    typealias Entity = User    func fetch(id: UUID) async throws -> User { /* … */ }    func save(_ user: User) async throws { /* … */ }}
// ❌ DON'T: use classes as base types when a protocol fitsclass BaseRepository {  // Avoid class inheritance for shared behavior    func fetch(id: UUID) async throws -> Any { fatalError("Override required") }}

Actor for Thread Safety

swift

// ✅ DO: isolate mutable shared state in an actoractor ImageCache {    private var cache: [URL: UIImage] = [:]
    func image(for url: URL) -> UIImage? { cache[url] }    func store(_ image: UIImage, for url: URL) { cache[url] = image }}
// ❌ DON'T: use a class with manual lockingclass UnsafeImageCache {    private var cache: [URL: UIImage] = [:]    private let lock = NSLock()  // Error-prone; prefer actor isolation    func image(for url: URL) -> UIImage? {        lock.lock(); defer { lock.unlock() }        return cache[url]    }}

// ✅ DO: isolate mutable shared state in an actoractor ImageCache {    private var cache: [URL: UIImage] = [:]
    func image(for url: URL) -> UIImage? { cache[url] }    func store(_ image: UIImage, for url: URL) { cache[url] = image }}
// ❌ DON'T: use a class with manual lockingclass UnsafeImageCache {    private var cache: [URL: UIImage] = [:]    private let lock = NSLock()  // Error-prone; prefer actor isolation    func image(for url: URL) -> UIImage? {        lock.lock(); defer { lock.unlock() }        return cache[url]    }}

Constraints

MUST DO

Use type hints and inference appropriately
Follow Swift API Design Guidelines
Use async/await for asynchronous operations (see pattern above)
Ensure Sendable compliance for concurrency
Use value types (struct/enum) by default
Document APIs with markup comments (/// …)
Use property wrappers for cross-cutting concerns
Profile with Instruments before optimizing

MUST NOT DO

Use force unwrapping (!) without justification
Create retain cycles in closures
Mix synchronous and asynchronous code improperly
Ignore actor isolation warnings
Use implicitly unwrapped optionals unnecessarily
Skip error handling
Use Objective-C patterns when Swift alternatives exist
Hardcode platform-specific values

Output Templates

When implementing Swift features, provide:

Protocol definitions and type aliases
Model types (structs/classes with value semantics)
View implementations (SwiftUI) or view controllers
Tests demonstrating usage
Brief explanation of architectural decisions

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation

Source and attribution

Source:jeffallan/claude-skillsinskills/swift-expertat commit1be15d8

License: MIT

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Swift Expert

Swift Expert

Core Workflow

Reference Guide

Code Patterns

async/await — Correct vs. Incorrect

SwiftUI State Management

Protocol-Oriented Architecture

Actor for Thread Safety

Constraints

MUST DO

MUST NOT DO

Output Templates

Source and attribution

More from jeffallan/claude-skills

Wordpress Pro

Vue Expert Js

The Fool

Sql Pro

Spring Boot Engineer

Spark Engineer

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Dpop Adoption

Gemini Live Api

Gemini Api