modern-swift

Q: How do I install modern-swift?

Run npx skills add https://github.com/johnrogers/claude-swift-engineering --skill modern-swift in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/modern-swift/ (personal) or .claude/skills/modern-swift/ (project).

by johnrogersMobile

Use when writing async/await code, enabling strict concurrency, fixing Sendable errors, migrating from completion handlers, managing shared state with actors, or using Task/TaskGroup for concurrency.

Installs: 180
Last 24h: —
Trending rank: —
Security: Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/johnrogers/claude-swift-engineering --skill modern-swift

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads modern-swift automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

Modern Swift (6.2+)

Swift 6.2 introduces strict compile-time concurrency checking with async/await, actors, and Sendable constraints that prevent data races at compile time instead of runtime. This is the foundation of safe concurrent Swift.

Overview

Modern Swift replaces older concurrency patterns (completion handlers, DispatchQueue, locks) with compiler-enforced safety. The core principle: if it compiles with strict concurrency enabled, it cannot have data races.

Quick Reference

Need	Use	NOT
Async operation	`async/await`	Completion handlers
Main thread work	`@MainActor`	`DispatchQueue.main`
Shared mutable state	`actor`	Locks, serial queues
Parallel tasks	`TaskGroup`	`DispatchGroup`
Thread safety	`Sendable`	`@unchecked` everywhere

Core Workflow

When writing async Swift code:

Mark async functions with async, call with await
Apply @MainActor to view models and UI-updating code
Use actor instead of locks for shared mutable state
Check Task.isCancelled or call Task.checkCancellation() in loops
Enable strict concurrency in Package.swift for compile-time safety

Reference Loading Guide

ALWAYS load reference files if there is even a small chance the content may be required. It's better to have the context than to miss a pattern or make a mistake.

Reference	Load When
Concurrency Essentials	Writing async code, converting completion handlers, using `await`
Swift 6 Concurrency	Using `@concurrent`, `nonisolated(unsafe)`, or actor patterns
Task Groups	Running multiple async operations in parallel
Task Cancellation	Implementing long-running or cancellable operations
Strict Concurrency	Enabling Swift 6 strict mode or fixing Sendable errors
Macros	Using or understanding Swift macros like `@Observable`
Modern Attributes	Migrating legacy code or using `@preconcurrency`, `@backDeployed`
Migration Patterns	Modernizing delegate patterns or UIKit views

Common Mistakes

@unchecked Sendable as a quick fix — Using @unchecked Sendable to silence compiler errors means you've opted out of safety. If the error persists after @unchecked, your code has a potential data race. Fix the underlying issue instead.
Missing await at call sites — Forgetting await when calling async functions is a compiler error, but checking Task.isCancelled in a loop without calling Task.checkCancellation() silently ignores cancellation.
Capturing self in async blocks without weak — Holding a strong reference to self in a long-running async task prevents deinit. Always use [weak self] in closures or use .task which auto-manages the lifecycle.
Not checking task cancellation — Long-running operations should regularly check Task.isCancelled or call Task.checkCancellation(), otherwise cancellation signals are ignored.
Forgetting @MainActor on UI code and test suites — Main test struct and view models that update @Published properties need @MainActor. Forgetting it silently allows cross-thread mutations. Apply @MainActor to: view models, view structs, main test structs, and any type that touches UI.
Actor re-entrancy surprises — await inside an actor method can release the lock temporarily. Another task may modify actor state. Design actor methods assuming state can change between await points.

FAQ

What does the modern-swift skill do?

Use when writing async/await code, enabling strict concurrency, fixing Sendable errors, migrating from completion handlers, managing shared state with actors, or using Task/TaskGroup for concurrency.

How do I install modern-swift?

Run npx skills add https://github.com/johnrogers/claude-swift-engineering --skill modern-swift in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/modern-swift/ (personal) or .claude/skills/modern-swift/ (project).

Which AI agents can use modern-swift?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is modern-swift safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains modern-swift?

It is published by johnrogers in johnrogers/claude-swift-engineering. It has 180 recorded installs.