just-works: Skill for Claude Code

Swift Coding

Match the project's existing conventions. When uncertain, read 2-3 existing files to infer the local style. Check Package.swift or .xcodeproj/.xcworkspace for Swift version, platform targets, and dependencies. New Xcode 26+ app projects default to Approachable Concurrency (Swift 6.2+) with main-actor isolation for app module code — assume this default unless the project explicitly disables it. These defaults apply only when the project has no established convention.

Never rules

These are unconditional. They prevent bugs and vulnerabilities regardless of project style.

• Never force unwrap (!) outside tests and controlled contexts — crashes at runtime with no recovery path. Use guard let, if let, ??, or optional chaining. Force unwrap is acceptable in tests, @IBOutlet, and when failure is provably a programmer error with an explaining comment.
• Never try! outside tests — crashes on any error. Use do-catch, try?, or propagate with throws. A network timeout, a missing file, a malformed response — any of these kill your process silently with no chance to recover or report.
• Never bare catch { } without handling — silently swallows errors. Catch specific error types, or log and rethrow. A decode failure looks the same as a permission error, and you'll never know which one is happening in production.
• Never [weak self] without checking for nil — accessing self after capture without guard let self leads to silent no-ops or partial execution. Half-completed operations are worse than failures because they corrupt state without raising errors.
• Never mutable global or static state — shared mutable state causes data races. Use actors, @MainActor, or dependency injection. The Swift 6 concurrency model will flag these as compile errors, so fix them now.
• Never blocking calls on MainActor — no Thread.sleep(), synchronous network calls, or heavy computation on the main thread. Use Task, async/await, or dispatch to a background context. Blocking main freezes the UI and triggers watchdog kills on iOS.
• Never x = x + y to build strings in loops — use += or append(contentsOf:), which grow the buffer in place (amortized, via copy-on-write), or joined(separator:) for collections. x = x + y allocates and copies a fresh string every iteration.
• Never hand-roll cryptographic key material — use CryptoKit (SymmetricKey(size:)) or SecRandomCopyBytes for keys, tokens, and session IDs. For general randomness, Int.random(in:) and SystemRandomNumberGenerator are fine — the system RNG is cryptographically secure.
• Never print() in production code — use os.Logger or OSLog. print is not filterable, not structured, and persists in release builds. It cannot be searched in Console.app and adds noise to device logs.
• Never class when struct suffices — default to value types. Use class only when you need reference semantics, inheritance, or identity. Value types avoid retain/release overhead and are safe to copy across threads — though closure captures, existential boxes, and CoW buffers can still put struct storage on the heap.
• Never retain cycles in closures — escaping closures capturing self in classes must use [weak self] or [unowned self]. Retain cycles cause silent memory leaks that accumulate over app lifetime, eventually triggering OOM kills.
• Never Any or AnyObject when a protocol or generic suffices — type erasure disables compile-time checking. Use generics, some, or any with specific protocols. A runtime cast failure is always worse than a compile error.