swift▌

Write, review, and migrate Swift tests using modern Swift Testing APIs with parallel execution and clear diagnostics. \n \n Covers test structure, #expect / #require macros, traits, tags, parameterized tests, and async waiting patterns for readable, maintainable tests \n Guides incremental XCTest migration while preserving UI automation and performance-metric tests that require XCTest \n Prioritizes parallel-safe test design; recommends fixing shared state before applying .serialized isolation \

Core Principle: Optimize Swift code by understanding language-level performance characteristics—value semantics, ARC behavior, generic specialization, and memory layout—to write fast, efficient code without premature micro-optimization.

Swift Testing is Apple's modern testing framework introduced at WWDC 2024. It uses Swift macros (@Test, #expect) instead of naming conventions, runs tests in parallel by default, and integrates seamlessly with Swift concurrency.

Core Swift language features and modern syntax patterns targeting Swift 6.3. Covers language constructs, type system features, Codable, string and collection APIs, formatting, C interop (@c), module disambiguation (ModuleName::symbol), and performance attributes (@specialized, @inline(always)). For concurrency (actors, async/await, Sendable), see the swift-concurrency skill. For SwiftUI views and state management, see swiftui-patterns.

Modern Swift testing framework with @Test macros, parameterized tests, traits, and async support. \n \n Write unit tests using @Test macros with #expect and #require assertions; prefer Swift Testing over XCTest for all new tests (Xcode 16+, Swift 6+) \n Organize tests with @Suite for grouping, custom tags for filtering, and traits for conditional execution, time limits, and known issues \n Support parameterized tests via arguments: with enum cases, ranges, or cartesian products; use confirmation

Resolve Swift 6.2 concurrency errors and adopt data-race-safe async patterns. \n \n Diagnose and fix actor isolation, Sendable conformance, and strict concurrency compiler diagnostics with a structured triage workflow \n Apply SE-0466 default MainActor isolation, SE-0461 nonisolated(nonsending), @concurrent functions, and Task.immediate for minimal behavior changes \n Design actor-based architectures, structured concurrency with TaskGroup and async let, and proper task cancellation patterns \n M

Single-threaded by default with explicit background offloading via @concurrent and isolated protocol conformances. \n \n Async functions stay on the calling actor by default, eliminating implicit background offloading that caused data-race errors in Swift 6.1 and earlier \n Isolated conformances allow MainActor types to safely conform to non-isolated protocols without unsafe workarounds \n @concurrent attribute explicitly offloads CPU-intensive work to background threads; requires nonisolated ty

Protocol-based dependency injection for testable Swift code with focused abstractions and Swift Testing. \n \n Define small, single-responsibility protocols for each external concern (file system, network, APIs) and provide default production implementations \n Create mock implementations with configurable error properties to test failure paths deterministically without real I/O \n Inject dependencies via default parameters so production code uses real implementations automatically while tests o

Thread-safe data persistence in Swift using actors with in-memory cache and file-backed storage. \n \n Implements an actor-based repository pattern that eliminates data races at compile time, replacing manual synchronization with Swift's actor model \n Combines fast O(1) in-memory lookups with atomic file persistence, supporting any Codable & Identifiable model type \n Provides synchronous initialization to avoid async complexity, with automatic await enforcement on all public API calls \n

Swift code style conventions for clean, readable, and idiomatic code. \n \n Enforces naming conventions (UpperCamelCase for types, lowerCamelCase for everything else) and prioritizes clarity over brevity \n Advocates the \"golden path\" pattern: early returns and guards to keep happy-path logic left-aligned, avoiding deep nesting \n Covers code organization with extensions and MARK comments, memory management with weak captures, and access control best practices \n Identifies five common mistake