Those Who Swift - Issue 274

Fable 5 is back! At least for a little while. 🤞

Anthropic has extended its availability until July 12, giving developers a few more weeks to work with the model before the next planned change.

The announcement turned out to be more controversial than expected. When access to Fable 5 was initially reduced, many users were automatically moved back to Claude 4.8. While still a capable model, plenty of developers noticed the difference. Longer reasoning, more consistent code generation, and overall responsiveness were among the areas where Fable 5 had earned its reputation. Going back felt less like a version update and more like losing a favorite development tool.

This situation also highlights an interesting challenge of cloud AI. Unlike traditional software, where you decide when to upgrade or downgrade, modern AI services can change underneath your workflow. The same prompt may produce different results depending on the currently available model, making consistency another variable developers have to consider.

Whether Fable 5 stays longer or not, one thing is clear: developers quickly adapt to better tools, and going backwards is never an easy sell.

Are you using Fable 5 in your daily workflow, or has another model become your primary coding assistant?

Artem Mirzabekian gives a clean mental model for something a lot of teams are still treating as vague tooling folklore.

• The article separates repository rules, Claude project memory, and reusable skills into distinct jobs
• The practical value is in making agents less guessy: small instruction files for always-on rules, skills for repeatable workflows, and CI for anything that must be enforced

Swift’s June digest feels more substantial than usual because WWDC26 gave it a lot to work with, from language changes to ecosystem moves and major open-source announcements.

• The biggest updates include Swift 6.4 previews, Swift in parts of Apple’s kernel, an open-sourced QUIC transport layer, and new Foundation Models utilities
• It also works well as a community snapshot, pulling in Swift Package Index joining Apple, the new Networking workgroup, notable package releases, and a few evolution proposals worth tracking

Antoine van der Lee revisits defer through a modern Swift lens, which makes the article more useful than a basic keyword refresher.

• It covers both the classic cleanup use case and the newer Swift 6.4 ability to await inside defer when the surrounding context is async
• One of the clearest points is why Task { ... } is not a real replacement here: unstructured cleanup can outlive the function, while async defer preserves the guarantee that cleanup finishes before scope exit

Natascha Fadeeva explains Sendable from the angle that matters most in real code: what happens when values cross tasks, actors, and other concurrency boundaries.

• Sendable marks types that are safe to pass across concurrency boundaries, and Swift 6 treats violations much more strictly than Swift 5’s default mode
• The article is strongest where it gets practical about classes: immutable final classes can conform, mutable shared state usually belongs in an actor, and @unchecked Sendable should be treated as a manual safety promise, not a warning silencer

Ralf Ebert’s note is short, but it clears up a visual detail that is easy to miss when trying the new shape APIs.

• ConcentricRectangle and ContainerRelativeShape both adapt to outer rounded container shapes, but they do not behave the same once positioning shifts
• The key distinction is practical: ConcentricRectangle is more tied to actual corner geometry, while ContainerRelativeShape stays more uniform as a general container-aware shape

Article explains a small beta API change to make a bigger point about how display-driven work should be modeled in modern UIKit.

• The article clearly separates Timer from CADisplayLink: one is interval-based, the other is tied to frame boundaries and visual smoothness
• The new part in iOS 27 is scene ownership, where display-synchronized work can be attached to a specific UIWindowScene instead of feeling like a loose global loop

Natalia Panferova takes a very specific SwiftUI pattern and turns it into a useful performance lesson about how bindings are represented.

• Binding(get:set:) is flexible, but recreating closure-based bindings in body can trigger extra row updates when unrelated state changes
• A subscript-based binding gives SwiftUI a more stable projection to track, so child views only reevaluate when the relevant state actually changes

Anthropic is expanding Claude Cowork beyond desktop, which changes the product from a laptop-bound agent into something that can follow work across devices.

• Cowork is rolling out to web and mobile first for Max users, with more plans to follow over the next several weeks
• The bigger shift is background continuity: sessions, files, and approvals can now move between desktop, phone, and web while Claude keeps working even when no device is online

Sagar Unagar highlights a small SwiftUI addition that will probably get used a lot more than its size suggests.

• .crossFade gives SwiftUI a built-in fade transition with almost no setup
• It fits screens like settings, forms, editors, and login flows better than zoom-style transitions

Artem Mirzabekian and Bogdan Poplauschi use the first Swift Academy episode to push performance discussions away from vague “fast or slow” claims and toward how apps actually feel in production.

• A technically fast app can still feel slow if feedback arrives late, state updates wake too much UI, or performance only looks good on modern devices
• The episode also cuts through common myths around SwiftUI, UIKit, averages, and concurrency, with one clear message: measure real user experience, not just pretty local metrics

Stewart Lynch walks through two different reordering paths for SwiftData-backed content, starting with the built-in List move flow and then building full drag-and-drop behavior for a grid.

• The list version is simple: use onMove, update sortOrder, and save back through modelContext
• The grid version is the more useful part: keep a local display array for drag state, reorder it with a custom drop delegate, then persist the final order only when the drop completes

Anubhav Giri positions this as a fundamentals-first iOS engineering resource built around two topics that trip up a lot of developers once apps get real.

• Volume 1 focuses on memory and concurrency
• From the page snippet, it looks aimed at system-level foundations rather than framework tips

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇