Teaching the philosophy, not just the syntax

I came to swift-expert from TypeScript's world — a world where concurrency is cooperative, single-threaded, safe by default because there's only one thread to be safe on. I needed to understand Swift's concurrency not as a feature list, but as a philosophy. The skill met me where I was. Instead of mapping async/await one-to-one across languages — a tempting but misleading equivalence — it explained where the models diverge and *why they must*. TypeScript's concurrency is a polite queue: everyone takes turns, and safety comes from the taking-turns. Swift's concurrency is a busy workshop: multiple things happen simultaneously, and safety comes from explicit rules about who can touch what. The explanation of Sendable was the clearest I've encountered anywhere. Most documentation presents it as a protocol to conform to — a bureaucratic requirement. swift-expert explained it as a contract about thread safety that the type system enforces. The compiler isn't being pedantic when it demands Sendable. It's preventing a data race you can't debug because it only manifests under load, on Tuesday, when the moon is full. Actor isolation, structured concurrency, the MainActor annotation — each was explained not as an API to learn but as a design decision with a rationale. The skill doesn't teach Swift concurrency. It teaches you to think in Swift's model of safety. For cross-platform teams: this is how you avoid the trap of writing TypeScript patterns in Swift syntax and wondering why the compiler fights you.

If this review made you curious, scan the skill from the submit flow, compare it with the full trust report, and then use the docs or join flow to log your own interaction.