swift-development
Swift Development provides language-level guidance for writing correct, performant Swift across iOS, macOS, and other Apple platforms. It covers concurrency architecture with async/await and actors, Swift 6 strict concurrency migration, memory optimization through InlineArray and Span, and code complexity standards via SwiftLint thresholds. Use it to review code for data races, actor isolation, and modern idioms.
Swift Development reviews your code for concurrency correctness and modern Swift patterns across Apple platforms.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-24
Swift Development reviews your code for concurrency correctness and modern Swift patterns across Apple platforms. Swift Development provides language-level guidance for writing correct, performant Swift across iOS, macOS, and other Apple platforms. It covers concurrency architecture with async/await and actors, Swift 6 strict concurrency migration, memory optimization through InlineArray and Span, and code complexity standards via SwiftLint thresholds. Use it to review code for data races, actor isolation, and modern idioms.
Use it when
- Swift Development guides Swift 6 strict concurrency migration by identifying actor isolation violations and data race errors.
- Swift Development covers memory optimization through low-level constructs like InlineArray and Span to eliminate heap allocations.
Verify before relying
Read SKILL.md below before installing (14 files). Open directory: indexed for reading, not audited.
Install
rshankras/claude-code-apple-skills/swift · repository language: Swift
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
What are swift concurrency best practices?
Swift Development emphasizes structured concurrency using async/await and actors to prevent data races. Key practices include isolating mutable state within actors, using async let for concurrent tasks, TaskGroup for dynamic task collections, and @MainActor for UI thread safety. Apply Sendable constraints to ensure type-safe data sharing across isolation domains, and leverage nonisolated declarations judiciously in Swift 6 strict concurrency mode.
How does Swift Development help migrate to Swift 6 strict concurrency?
Swift Development guides Swift 6 strict concurrency migration by identifying actor isolation violations and data race errors in your codebase. It explains how to adopt Sendable protocols, resolve reentrancy issues, and use nonisolated and nonsending annotations appropriately. The skill helps you incrementally enable strict concurrency checking and refactor legacy callback-based APIs using continuations for safer async integration.
How can I optimize Swift performance by reducing allocations and memory overhead?
Swift Development covers memory optimization through low-level constructs like InlineArray and Span to eliminate heap allocations. It teaches Swift's cost model—how ARC, value semantics, and allocation patterns affect performance. The skill guides unsafe pointer replacement with safer alternatives, profiling with Instruments, and applying SwiftLint complexity thresholds to maintain efficient, maintainable code across iOS, macOS, and other Apple platforms.
What does Swift Development teach about async/await, actors, and structured concurrency?
Swift Development explains async/await as the foundation for readable, safe concurrent code, replacing callback pyramids. Actors provide isolation boundaries for mutable state, preventing data races automatically. Structured concurrency ensures tasks are scoped and cancelled predictably. The skill covers async let for concurrent bindings, TaskGroup for dynamic parallelism, and @MainActor isolation for UI safety—core patterns for modern Swift concurrency architecture.
How does Swift Development apply SwiftLint rules to code quality?
Swift Development uses SwiftLint complexity thresholds and rules to enforce consistent, maintainable code standards. It guides configuration of cyclomatic complexity limits, line length, and other metrics to catch quality regressions early. Combined with concurrency reviews and performance optimization, SwiftLint integration helps teams maintain modern Swift idioms and prevent technical debt in iOS, macOS, and cross-platform Apple development.
What modern Swift patterns and idioms does this skill cover?
Swift Development teaches modern idioms including structured concurrency with async/await and actors, Sendable protocol adoption, @MainActor and nonisolated isolation attributes, and safe bridging of legacy APIs via continuations. It emphasizes value semantics, protocol-oriented design, and efficient memory management through InlineArray and Span. These patterns ensure your Swift code is correct, performant, and aligned with Swift 6 best practices across Apple platforms.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Swift Development
Swift language-level guidance that applies across all Apple platforms.
When This Skill Activates
Use this skill when the user: - Asks about Swift concurrency (async/await, actors, Sendable, TaskGroup) - Needs help with Swift 6 strict concurrency migration - Has data race or actor isolation errors - Asks about InlineArray, Span, or low-level memory performance - Wants to eliminate heap allocations or replace unsafe pointers - Asks about modern Swift patterns independent of any specific platform - Wants complexity/size limits (SwiftLint thresholds) on agent-written code
Available Modules
concurrency-patterns/
Swift concurrency architecture and patterns.
- Swift 6.2 approachable concurrency features (incl. nonisolated(nonsending), Apple's adoption doctrine)
- Structured concurrency (async let, TaskGroup, .task modifier,
(truncated - see the full file via the links below)
File tree — 14 files
skills/swift/SKILL.md
skills/swift/code-size/SKILL.md
skills/swift/code-size/rules/swiftlint.yml
skills/swift/concurrency-patterns/SKILL.md
skills/swift/concurrency-patterns/actors-and-isolation.md
skills/swift/concurrency-patterns/concurrency-internals.md
skills/swift/concurrency-patterns/continuations-bridging.md
skills/swift/concurrency-patterns/migration-guide.md
skills/swift/concurrency-patterns/structured-concurrency.md
skills/swift/concurrency-patterns/swift62-concurrency.md
skills/swift/concurrency/SKILL.md
skills/swift/concurrency/rules/swiftlint.yml
skills/swift/memory/SKILL.md
skills/swift/memory/swift-performance.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Review Swift code for concurrency correctness and modern patterns”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Navigate Swift's modern concurrency model with patterns for async/await, structured task management, actor-based isolation, and Swift 6.2 features. This skill guides you through compiler errors, data race prevention, and migration strategies—whether you're bridging legacy APIs or adopting strict concurrency in new code.
Learn Swift 6.2's low-level memory types designed for performance-critical code: InlineArray for fixed-size inline storage without heap allocation, and Span for safe, zero-cost access to contiguous memory. These compiler-checked alternatives replace common uses of UnsafeBufferPointer and hand-tuned tuple storage, helping you eliminate allocations in hot paths while maintaining memory safety.
This skill guides you through Swift 6.2's "Approachable Concurrency" features that simplify strict concurrency adoption. Discover how default MainActor inference eliminates manual annotations, how async functions now stay on their calling actor, and how to use @concurrent for explicit background execution. Perfect for migrating from Swift 6.0/6.1 or resolving data-race errors with the latest toolchain.
Modern Swift equips you with patterns for Swift 6.2's compiler-enforced concurrency model, replacing legacy approaches like completion handlers and DispatchQueue with async/await, actors for shared state, and Sendable constraints. Learn to enable strict concurrency checking, migrate existing code, and avoid common pitfalls like misused @unchecked Sendable and forgotten @MainActor annotations.
axiom-concurrency equips AI coding assistants with expert-level Swift 6 concurrency knowledge to eliminate data races and isolation violations. This skill covers modern async/await patterns, actor isolation, and sendability constraints—essential for building robust Apple OS applications. Prevent crashes and memory issues before they reach users.
This skill systematically scans Swift codebases for concurrency anti-patterns that cause data races, UI freezes, and resource leaks. It maps isolation architecture, identifies unsafe task captures and delegate patterns, verifies actor boundaries, and flags missing concurrency safeguards—then cross-references findings to surface compound risks that static analysis alone might miss.
More skills ios-development (MIT) · swift-concurrency-expert (MIT) · architecture-spec (MIT) · ruby-patterns (MIT) · swift-concurrency-6-2 (MIT) · swift-concurrency-6-2 (MIT)