Swift language

Swift to the Max

Expert-level guidance for modern Swift. The goal: code that a senior Swift engineer in 2026 would write — strict-concurrency-clean, value-semantic by default, expressive at the type level, and honest about performance.

Version landscape (mid-2026)

Version	Status	Headline features
Swift 5.10	legacy	last 5.x; complete strict-concurrency checking under -strict-concurrency=complete
Swift 6.0	2024	Swift 6 language mode (data-race safety by default), typed throws, count(where:), 128-bit ints
Swift 6.1	2025	trailing commas everywhere, nonisolated on types/extensions, package traits
Swift 6.2	2025	approachable concurrency: default MainActor isolation (opt-in), nonisolated(nonsending) / @concurrent, InlineArray, Span/MutableSpan, opt-in strict memory safety, Observations, backtraces on crash
Swift 6.3	Mar 2026, current stable	@c attribute (expose Swift to C), official Android SDK, Swift Build preview in SwiftPM, @specialized / @inline(always), module selector syntax (ModuleName::Type), completed Embedded Swift feature set
Swift 6.4	WWDC26 beta	await in defer, Iterable protocol (borrowing iteration), anyAppleOS availability shorthand, @diagnose, Swift Testing ↔ XCTest interop, unified URL implementation

Default to Swift 6 language mode semantics unless the project's Package.swift / build settings say otherwise. Check // swift-tools-version: and swiftLanguageModes: before assuming. Never emit code using a beta-only (6.4) feature without flagging it as such.

Non-negotiable defaults

These apply to essentially all new Swift code; deviate only when the surrounding codebase clearly does otherwise, and say so.

• Value types first. struct/enum unless you need identity, inheritance, or reference semantics. If you reach for class, ask whether it should be an actor or final class.
• Strict concurrency clean. No @unchecked Sendable without a written justification (a lock or immutability argument). No DispatchQueue in new code — use actors, Task, TaskGroup, AsyncSequence, Mutex (Synchronization module, 6.0+).
• some before any. Existentials (any P) cost dynamic dispatch and boxing; opaque types (some P) keep static dispatch. Use any only when you genuinely need heterogeneity.
• Exhaustive switch over if-chains for enums; avoid default: when you can enumerate cases — it silences the compiler when new cases appear.
• No force unwraps / force try in production paths. ! is acceptable only for programmer-error invariants, and then prefer guard let ... else { preconditionFailure("why") } so the invariant is documented.
• Typed throws (throws(MyError)) for closed error domains (libraries, embedded); plain throws for application-level composition.
• guard for early exit, one happy path at low indentation.
• API names follow the Swift API Design Guidelines — fluent at the call site, omit needless words (details in references/api-design-and-errors.md).

Idiom translation table

When reviewing or migrating, rewrite the left column on sight:

Legacy	Modern
DispatchQueue.global().async { ... }	Task { ... } / Task.detached (rare) / @concurrent func
DispatchQueue.main.async { ... }	@MainActor function or MainActor.run
completion handlers (Result<T, Error>) -> Void	async throws -> T (bridge with withCheckedThrowingContinuation)
NSLock / os_unfair_lock	Mutex<State> (Synchronization) or an actor
class Foo: NSObject + KVO	@Observable (Observation framework)
Array fixed-size hot buffers	InlineArray<N, T> (6.2+)
UnsafeBufferPointer parameters	Span<T> / RawSpan (6.2+)
NotificationCenter + selectors	AsyncSequence (notifications(named:)) or Observations
stringly-typed keys	nested enums / RawRepresentable structs
#if os(iOS) || os(macOS) || ... across all Apple OSes	anyAppleOS (6.4+, flag as beta)

Workflow

1. Detect the project's Swift version and language mode first (Package.swift, .xcodeproj settings, swift --version). Guidance shifts meaningfully between 5.x, 6.0/6.1, and 6.2+ (default MainActor isolation may be on).
2. Load the relevant reference file(s) below — they carry the depth; this file only carries defaults.
3. Compile what you write when a toolchain is available (swift build, swiftc -typecheck, or xcodebuild). Swift's type checker is the cheapest reviewer you have. For snippets, wrap in a scratch package or swiftc -typecheck a single file.
4. Run the review checklist (bottom of this file) before declaring code done.

Reference routing

Read the file whose domain the task touches. Multiple may apply; read all that do.

Topic	File	Read when…
Concurrency	references/concurrency.md	actors, async/await, Sendable errors, isolation, tasks, streams, migration to Swift 6 mode, 6.2 approachable-concurrency changes
Types & generics	references/types-and-generics.md	protocols, some/any, associated types, parameter packs, noncopyable (~Copyable) & ~Escapable types, phantom types, result builders
Memory & performance	references/memory-and-performance.md	ARC, retain cycles, COW, consuming/borrowing, InlineArray/Span, @specialized/@inline(always), allocation profiling, Instruments
API design & errors	references/api-design-and-errors.md	naming, library ergonomics, typed throws, error architecture, availability, documentation comments
Macros	references/macros.md	writing or debugging @attached/@freestanding macros, SwiftSyntax, macro testing
SwiftPM & tooling	references/swiftpm-and-tooling.md	Package.swift authoring, traits, plugins, Swift Build, swiftly, CI setup, pinning toolchains
Interop & platforms	references/interop-and-platforms.md	C/C++/ObjC bridging, @c, Android SDK, Linux/server, Embedded Swift, WASM
Testing	references/testing.md	Swift Testing (@Test, #expect), parameterized tests, XCTest migration/interop, async testing

Review checklist

Run through this before presenting any nontrivial Swift code:

1. Does it compile under the project's language mode? (Actually check when possible.)
2. Any data-race-safety diagnostics it would trip in Swift 6 mode? Any @unchecked Sendable, nonisolated(unsafe), or @preconcurrency without justification?
3. Retain cycles: every escaping closure stored on a class/actor audited for [weak self] need — and no cargo-cult [weak self] where the closure is short-lived (task bodies that finish quickly are fine holding self strongly, if that lifetime is intended).
4. Force unwraps, try!, as! — each one justified or removed.
5. Public API: names read as English phrases at the call site; parameters have sensible defaults; types are Sendable where users will need them to be.
6. Errors: can callers distinguish the failures they need to handle? Is anything swallowed silently (try? discarding actionable errors)?
7. Performance red flags in hot paths: unnecessary existentials, repeated Array reallocation without reserveCapacity, string concatenation in loops, O(n) count checks on lazy sequences.
8. Availability: does the code use symbols newer than the stated deployment target without @available guards?

When NOT to over-apply this skill

• Small scripts and prototypes: correctness and clarity beat architecture. Don't wrap a 30-line script in actors and protocols.
• Existing codebases: match local conventions first; propose modernization separately rather than mixing it into a feature diff.
• Beta features (6.4 as of mid-2026): mention, don't silently use.

Companions & orchestration

Part of the swift-tothemax plugin — apple-dev-conductor routes multi-facet tasks. Siblings: swiftui-max owns the view layer; hand UI questions there. This skill owns everything beneath it. Ecosystem companions (delegate the sub-task if installed, keep this skill's 2026 version facts): swift-concurrency / swift-concurrency-pro for concurrency-correctness review of diffs; swift-testing-pro / swift-testing-expert for test-suite review; swiftdata / swiftdata-pro for persistence layers. If both this skill and a companion produce a checklist, merge and run once.