mcpField
S
swift-development

swift-development

github.com/rshankrasDevelopment838491 installsUpdated 14w ago
Repository

About swift-development

A cross-platform Swift guidance skill for developers working with concurrency, memory performance, and code-size limits. It organizes focused reference modules, including Swift 6.2 migration notes and low-level memory topics.

Key features

  1. 01Swift concurrency architecture guidance
  2. 02Swift 6.2 change and migration reference
  3. 03Concurrency isolation and data-race guidance
  4. 04InlineArray and Span memory guidance
  5. 05Swift code complexity and size limits

Use cases

  1. 01Migrating a project to Swift 6 strict concurrency
  2. 02Diagnosing actor isolation or data-race errors
  3. 03Understanding Swift 6.2 concurrency changes
  4. 04Reducing allocations in performance-sensitive code

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/rshankras/claude-code-apple-skills --skill swift-development

After installing, type/swift-developmentin Claude Code to confirm it loaded.

Bundled files

References and scripts installed along with SKILL.md.

code-size/rules/
swiftlint.yml
concurrency-patterns/
actors-and-isolation.md
concurrency-internals.md
continuations-bridging.md
migration-guide.md
structured-concurrency.md
swift62-concurrency.md
concurrency/rules/
swiftlint.yml
memory/
swift-performance.md

Details

From the project README

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, task-local values)
  • Actors, isolation, reentrancy, @MainActor, Sendable
  • Runtime internals + profiling (cooperative pool, unsafe primitives, Swift Concurrency Instrument)
  • Continuations for bridging legacy APIs
  • Swift 6 strict concurrency migration guide
concurrency/

Swift 6.2 concurrency updates reference — the what-changed view (async-stays-on-caller, default MainActor inference, isolated conformances, @concurrent) with migration steps from 6.0/6.1 and top mistakes. Overlaps concurrency-patterns/swift62-concurrency.md by design: use this file when the question is "what changed in 6.2?", use concurrency-patterns when building or reviewing async code.

code-size/

Complexity and size limits for Swift code — SwiftLint threshold rules (cyclomatic complexity, function/type/file length, parameter count) with a violations-baseline adoption path so existing code never blocks. Part of the deterministic gauntlet with testing/fitness-functions and testing/coverage-ratchet.

memory/

InlineArray, Span, and the Swift performance cost model.

  • InlineArray: fixed-size, stack-allocated collections with zero heap overhead
  • Span family: safe, non-escapable access to contiguous memory (+ OutputRawSpan, swift-binary-parsing)
  • Lifetime dependencies and non-escapable type constraints
  • swift-performance.md: the cost model — allocation, ARC/retain-release, exclusivity checks, dispatch, generics vs existentials, closures, ~Copyable ownership

How to Use

  1. Identify user's need from their question
  2. Read relevant module files from subdirectories
  3. Apply the guidance to their specific context
  4. Cross-reference with platform-specific skills (ios/, macos/) as needed

Comments

Markdown supported