Those Who Swift

Those Who Swift - Issue 275

Wed, 15 Jul 2026 21:18:55 GMT

Weekly note ✏️

We have a new team member! 🙋‍♀️

Divya Ravi, Senior iOS Engineer at Unity and creator of FoundationModelsKit, is joining Those Who Swift as a new newsletter editor.

If you’d like to get to know Divya, check out her LinkedIn and X.

Anton isn’t going anywhere!

He’s now the editor of our new website - which brings me to the second big news. 🥳

We now have a blog with unique, quality content.

New content, collaborations, partnerships, special deals, and more coming soon. Stay tuned! 😎🤘

Own Your web2app Funnel and Get Paid in Days

web2wave lets subscription apps sell on the web first: users complete a quiz flow, pay, then download the app with an active subscription. The sale closes before install, so you don’t pay 15-30% app store fees on it.

Get paid in 1-2 days instead of 30+, for much faster cash flow.
Build the full funnel with the no-code editor, or in a minute with Wavy AI or the web2wave MCP.
Ship A/B tests and cancellation flows without waiting on app releases.
Keep full web-side tracking and UTM attribution, even post-ATT.

Payment coverage in web2app: direct integrations with Paddle, Stripe, Solidgate, FastSpring, Zotlo, Unlimit, Xsolla, PayPal, Billerix, and 100+ more via Primer.

Free to use until you launch paid traffic.

Try web2wave free

Post-WWDC26: The 3 On-Device AI Patterns That Will Actually Ship This Year

with Divya Ravi — Technical Editor & iOS engineer, creator of FoundationModelsKit

Every June, WWDC produces the same split-screen reaction: a keynote full of features that sound revolutionary, followed by a developer community quietly asking which of them will actually be usable in a shipping app before next June. This year is no different. Between Siri AI, Private Cloud Compute, and a redesigned Foundation Models framework, there’s a lot to sort through — and most of the coverage so far has just listed announcements rather than telling you what to actually build against.

So here are the three patterns from WWDC26 I think are worth architecting around this cycle — not because they’re the flashiest, but because they’re the ones you can ship on, today, without waiting for a keynote demo to become real.

1. Model portability is no longer a side project — it’s a protocol.

Apple’s new LanguageModel protocol means your app’s AI logic doesn’t have to be married to Apple’s on-device model anymore. Swap in Claude, swap in Gemini, or fall back to on-device — all through the same session interface, with your tool calls and context management untouched. In practice, this turns a decision that used to require re-architecting your AI layer into a Swift Package Manager dependency change.

Why it matters: most teams have been quietly hedging against being locked into Apple’s model quality, especially for anything requiring nuanced reasoning. This protocol makes that hedge free. If your app currently has model logic tangled into your view layer or business logic, this is the year that tech debt gets expensive — everyone else’s app is about to be able to swap providers in an afternoon, and yours won’t be if the session boundary isn’t clean.

2. Bring-your-own-model finally has a real home: Core AI.

Core AI is Apple’s new answer to teams who don’t want to use Apple’s model at all — a full on-device deployment framework with a Python conversion pipeline and a Swift runtime, tuned to run across CPU, GPU, and Neural Engine without a server dependency. This has existed in rougher form via Core ML for years, but Core AI is the first version that feels like a first-class platform citizen rather than a workaround.

Why it matters: if you’ve been holding off on shipping a proprietary or fine-tuned model because the on-device tooling felt like a science project, that excuse is gone. The teams who move now — while most of the ecosystem is still only using Apple’s default model — get a real differentiation window before “on-device AI” becomes table stakes and looks identical across every app in a category.

“None of these patterns are really about AI capability — they’re about architecture. The apps that struggle won’t fail because the AI is bad. They’ll fail because the plumbing underneath was never built to be swapped, extended, or exposed in the first place.”

3. App discovery is moving into the OS, not your app’s UI.

Between the Spotlight semantic index, App Intents schemas, and the new View Annotations API, Apple is making a clear bet: the primary way people invoke your app’s functionality is about to be Siri asking on their behalf, not someone tapping your icon. Annotate your views, expose your actions through App Intents, and your content becomes something the system can reason about and act on — conversationally, without you building any of that interface yourself.

Why it matters: this is the one pattern that’s easy to underestimate because it doesn’t produce a flashy demo. But it’s the one most likely to quietly redefine what “distribution” means for an app over the next two years. Ignore it and you’re opting out of an entire invocation surface your competitors will be inside of.

The thread connecting all three

Model portability rewards apps with clean session boundaries. Core AI rewards apps that already separate inference from UI. App Intents rewards apps that expose actions as first-class objects instead of burying them in view controllers. None of this is really about AI capability — it’s about whether your architecture was ready for it.

If you’re planning your roadmap around this WWDC cycle, the highest-leverage work isn’t picking which shiny feature to bolt on first. It’s making sure your architecture can say yes to any of the three.

Agree, disagree, or think I’m missing a pattern? Just hit reply — I read every one.

Apple 🍏

Foundation Models in iOS 27: Tool-Calling Control

Blake Crosley digs into the new ToolCallingMode API and Apple’s built-in OCR and barcode tools — the kind of detail that matters once you’re past the keynote demo and into shipping.

The new ToolCallingMode structure lets you control how aggressively the model calls tools mid-generation, and the framework can auto-switch modes to bound activity within a single request.
OCRTool and BarcodeReaderTool run entirely on-device, in your app’s own sandbox — Apple maintaining the recognition code changes who owns it, not where it runs.

Apple’s WWDC26 AI Story Is About Control, Not Just Models

Jon Brown’s read on the keynote pairs directly with this issue’s essay — if you only click one link this week, make it this one.

Argues Apple Intelligence has less to work with when an app’s data model is vague or its actions aren’t cleanly represented — architecture first, AI second.
Makes the case that App Intents should be treated as core app structure from day one, not a Siri checkbox bolted on near ship.

WWDC 2026 Developer Tools: Xcode 27, Swift, Foundation Models

A blunt, opinionated take — and one I don’t think is right, which is exactly why it’s worth reading.

Argues App Intents adoption is now effectively mandatory, since apps without it become invisible to Siri as an entry point.
I’d push back on “mandatory” for anything outside the productivity/utility category — but the underlying pressure is real and worth planning around either way.

Tutorials 📒

Getting Started with Apple’s Foundation Models

Artem Novichkov builds a HealthKit-powered health coaching feature using a custom Tool — the most practical, code-first entry point in this issue.

Walks through defining a custom Tool that pulls live blood pressure data from HealthKit into a LanguageModelSession.
Good starting point if you haven’t touched Foundation Models yet — minimal boilerplate to get a working tool-calling session running.

Introducing FoundationModelsKit: Production Patterns for Foundation Models on iOS

Full disclosure: this one’s mine — including it because it’s directly on-theme for this issue, not just because I wrote it. At WWDC26, Apple made a bold move: Foundation Models now ship with iOS, on-device, with no download or external dependency.

Walks through production patterns for actually shipping with Foundation Models, not just prototyping with it.
If you want the deeper technical background behind this issue’s essay, this is where it comes from.

Coding 👨‍💻

SwiftUI Best Practices, straight from Apple’s Xcode 27 Agent Skill

Antoine van der Lee dissects the actual Markdown reference files Apple bundled into Xcode 27’s SwiftUI agent skill — and it’s basically a written confirmation of this issue’s whole thesis.

The skill’s reference files split cleanly by concern — structure, data flow, environment, modifiers — all built around one idea: a view is SwiftUI’s unit of invalidation, and most performance problems come from invalidating more than you need to.
Worth reading even if you don’t use agents — it’s effectively Apple’s own internal SwiftUI style guide, now public.

Swift Bits: My Top Xcode CI Environment Variables

Anton digs into Apple’s environment variable reference for Xcode Cloud — unglamorous, but exactly the kind of thing that saves you an afternoon of debugging why CI behaves differently from your local machine.

Covers the popular variables for detecting which workflow, build action, and app target is running — the context most custom ci_scripts builds actually need.
A good reminder that hardcoded CI scripts age badly; context-aware ones survive team and project changes.

Design 🎨

5 biggest Liquid Glass changes in iOS 27 and macOS 27

A clear rundown of how Apple is walking back a year of Liquid Glass complaints — legibility, corner-radius consistency, and icon clarity all got real fixes this cycle.

Apple’s HI design director confirmed most of these improvements apply automatically to apps already using the Liquid Glass framework, with minimal developer work required.
macOS 27 finally standardizes corner radius across apps — a small detail, but one that’s been a visible inconsistency since Liquid Glass launched.

Other cool stuff 🧰

How I use FlowDeck to let my AI agent build and run my apps

Donny Wals on folding an agentic coding tool into his existing workflow — a good counterweight to the rest of this issue, since it’s about AI helping you build, not AI features inside what you ship.

Started using FlowDeck after the tool’s builder reached out following a post Donny made about managing AI agent context windows.
The interesting part isn’t the tool itself — it’s the workflow shift of agents opening PRs against real crash reports while you’re away from the keyboard.

Video 🎥

Build intelligent Siri experiences with App Schemas

Straight from Apple’s own WWDC26 session — Dan Niemeyer walks through exactly how Siri understands and acts on your app’s content, which pairs directly with pattern 3 in this issue’s essay.

Covers how App Entities model your existing content (a calendar event, a mail message, a photo) so the system can reason about it without you rebuilding your data model.
Demonstrates real cross-app actions, like Siri sending someone’s latest report by name — worth watching before you scope your own App Intents work this cycle.

Watch here.📍Level: Intermediate

Thanks for reading!

Got a pick worth featuring? 📬 Use the submission form and share with more than 15,000 developers.

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 274

Wed, 08 Jul 2026 20:56:14 GMT

Weekly note ✏️

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?

Swift Around the Web 🌐

AI Agent Skills For iOS Development

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

What’s New In Swift: June 2026 Edition

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

Coding 👨‍💻

Defer In Swift Explained With Code Examples

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

Understanding Sendable In Swift

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

Design 🎨

ConcentricRectangle And ContainerRelativeShape

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

Other cool stuff 🧰

iOS27: CADisplayLink for UIWindowScene

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

Custom Bindings In SwiftUI: Closures Vs Subscripts

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

AI 🤖

Claude Cowork On Web And Mobile

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

Tutorials 📒

SwiftUI .crossFade Navigation Transition In iOS 27

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

Video 🎥

Modern iOS Performance Myths: Episode 1

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

Watch here.📍Level: Intermediate

Reordering SwiftData In List And Grid

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

Watch here.📍Level: Intermediate

Books 📚

The iOS Core Engineering Series — Volume 1

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

Get here.📍

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 273

Wed, 01 Jul 2026 20:30:36 GMT

Weekly note ✏️

This week, Apple announced price increases across most of its hardware lineup, including MacBooks, iPads, HomePods, and Apple TV. The notable exception is the iPhone. According to the company, soaring memory and storage chip prices, driven largely by AI data center demand, have reached a point where Apple can no longer absorb the additional costs. Even Apple, with one of the strongest supply chains in the industry, isn’t immune to the global memory shortage.

This has another consequence for developers. Running open-source LLMs locally is becoming increasingly attractive as cloud services tighten token limits and subscription models. But local AI needs RAM, and lots of it. Machines with 64 GB, 96 GB, or 128 GB of unified memory are now significantly more expensive, with many high-memory Mac configurations selling at substantial premiums, even on the secondary market and major retailers. The cost of moving away from cloud AI is rising alongside the cost of staying with it.

We’re entering an interesting phase where AI isn’t limited by model quality anymore. Instead, it’s becoming constrained by infrastructure, memory availability, and cost. Choosing between cloud-hosted models and running them locally is no longer just a technical decision. It’s increasingly a financial one.

If hardware prices continue to rise, would you rather invest in a powerful local machine for open-source LLMs or continue relying on cloud AI subscriptions?

Swift Around the Web 🌐

Reordering Beyond List - SwiftUI iOS 27

Sagar Unagar highlights one of the most overdue SwiftUI upgrades in iOS 27: drag-to-reorder is no longer trapped inside List.

• reorderable() and reorderContainer(for:) bring native reordering to stacks, grids, and custom Layout types
• SwiftUI reports a ReorderDifference, while your app stays responsible for applying and persisting the move

A Custom Pull-to-Refresh In SwiftUI

Artem Mirzabekian treats pull-to-refresh as a state machine problem, which is what makes this custom approach feel more deliberate than most one-off gesture hacks.

• The component exposes the full refresh lifecycle, from pull progress to finishing animation
• It is built for cases where .refreshable is not enough, like branded indicators, custom thresholds, and tighter layout control

Coding 👨‍💻

Understanding Privacy Manifests In iOS

Natascha Fadeeva lays out privacy manifests as a practical Xcode task, not just another compliance checkbox.

• A PrivacyInfo.xcprivacy file declares collected data, tracking use, and required reason API access for your app or SDK.
• The article is especially useful around third-party SDKs and required reason APIs like UserDefaults, file timestamps, disk space, boot time, and active keyboard access.

Design 🎨

Where Should Loading State Live In SwiftUI?

Mohammad Azam uses a simple products example to make a larger architectural point about where state duplication starts to creep in.

• He argues for keeping loading state in the view while the store stays the single source of truth for data
• The article is really about tradeoffs: some solutions can work, but they can also duplicate state and make updates like add or refresh feel more awkward

Other cool stuff 🧰

SwiftUI Is One Graph, Over 40+ Years of Engineering

Mihaela Mihaljević Jakić’s post is less a SwiftUI tutorial and more an attempt to strip the framework down to its engine room.

• The central claim is that SwiftUI behaves like a single demand-driven graph, not a view tree that gets broadly diffed and rebuilt.
• It gets more interesting when the article connects that graph to the older stack beneath it — Core Animation, Core Graphics, Core Text, and Core Image — and argues that SwiftUI only really makes sense once you see the deeper machinery it sits on top of.

Proposing Task-Local Test Traits For Swift Testing

Point-Free’s proposal is small on the surface, but it targets a very real annoyance in test setup for task-local values.

• It would add a built-in .taskLocal trait, so tests could bind task locals without writing a custom trait for each one.
• The bigger benefit is less boilerplate and less need for separate test-support modules just to make task locals usable in Swift Testing.

AI 🤖

Previewing GPT-5.6 Sol: A Next-Generation Model

OpenAI is introducing a new three-tier GPT-5.6 family, with Sol as the flagship model, Terra as the balanced middle tier, and Luna as the faster lower-cost option.

• Sol adds new max reasoning and an ultra mode that uses subagents for more complex work.
• The preview is limited at first, with OpenAI emphasizing stronger safeguards, better coding performance, and broader availability in the coming weeks.

Introducing Claude Sonnet 5

Anthropic is positioning Claude Sonnet 5 as its most agentic Sonnet yet, aiming to bring Opus-like follow-through and tool use to a cheaper tier.

• It narrows the gap with Opus 4.8 on reasoning, coding, tool use, and knowledge work, while launching as the default model for Free and Pro plans.
• Pricing starts at $2 input / $10 output per million tokens through August 31, 2026, then moves to $3 / $15, with Anthropic also saying Sonnet 5 is safer than 4.6 overall and weaker than Opus models on dangerous cyber tasks.

Claude Science, An AI Workbench For Scientists, Is Now Available

Anthropic is pushing deeper into scientific workflows with a product that feels less like a chatbot and more like a research environment.

• Claude Science brings literature analysis, code, figures, manuscripts, and compute management into one workflow for scientists.
• It launches in beta on macOS and Linux for Pro, Max, Team, and Enterprise users, with a strong focus on biology and biomedical research.

Tutorials 📒

Using Cursor In Xcode 27

Pol Piella shows that Xcode 27’s agent support is open enough to bring Cursor into the workflow, not just Apple’s built-in or officially listed assistants.

• The setup is surprisingly direct: install Cursor’s CLI, point Xcode at the agent executable, and run it with the acpargument.
• The bigger story is Xcode 27 itself: ACP support means custom agents can now sit inside Xcode’s intelligence flow alongside first-party options.

Video 🎥

What’s New In SwiftUI For iOS 27?

Paul Hudson’s walkthrough makes it clear this is another unusually strong SwiftUI year, with improvements that range from under-the-hood compiler wins to features developers will feel immediately in app architecture and UI polish.

• The biggest changes are surprisingly quiet ones: @State is now a macro, View became a content builder, and both shifts aim to cut wasted work and reduce those infamous type-checking errors
• The visible additions are broad and practical — reordering outside List, swipe actions in custom layouts, prominent tabs, AsyncImage caching, crossfade navigation, smarter toolbars, and new APIs that hint at a more resizable future for iPhone apps

Watch here.📍Level: Intermediate

Books 📚

Mohammad Azam’s SwiftData Architecture is focused on the part most SwiftData content skips: how to build production apps, not toy samples.

It covers architecture, debugging, migrations, CloudKit, and performance.

Get 20% off with code: THS2026

Buy here.📍

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 272

Wed, 24 Jun 2026 20:16:01 GMT

Weekly note ✏️

This week brought two interesting pieces of news that, at first glance, seem unrelated. One is about trust and identity in the AI era. The other is about trust and community in the Swift ecosystem.

Anthropic has started rolling out identity verification for certain Claude users. Depending on the situation, users may be asked to provide a government-issued ID and a selfie through a third-party verification provider called Persona. Anthropic states that the data is used for safety, abuse prevention, and regulatory compliance, and that verification images are stored by Persona rather than directly by Anthropic. The company also says this information is not used for model training.

The timing is interesting. Over the last year we’ve seen multiple discussions around privacy, data leaks, account verification, and surveillance concerns across various platforms. As AI tools become more powerful and gain access to more capabilities, providers are naturally moving toward stronger identity controls. Whether users will accept that trade-off is another question entirely. Some developers are already looking at alternative models and providers that require fewer verification steps and collect less personal information.

On the Swift side, there was much more cheerful news. Swift Package Index is joining Apple. For years, SPI has been one of the most valuable community resources for discovering packages, evaluating maintenance quality, and helping developers make better dependency decisions. What started as a community project by Dave Verwer and Sven Schmidt has become such an important part of the ecosystem that Apple decided to bring it under its umbrella.

This is a great example of how community efforts can grow into essential infrastructure. Documentation, open-source libraries, newsletters, podcasts, and package indexes are all created by people who care enough to invest their time before anyone else sees the value. Apple recognizing that contribution is a positive signal for the entire Swift community.

As AI services move toward stricter identity checks and ecosystem platforms become more centralized, where do you draw the line between convenience and privacy? Would you consider switching to another LLM if it required fewer verification steps?

Swift Around the Web 🌐

UIPortalView: From Live Mirroring to Liquid Glass-Style Effects

Artem Mirzabekian uses _UIPortalView as a way to peek behind some of iOS’s most interesting visual tricks, especially where live mirroring starts to feel more like composition than ordinary view rendering.

• The article shows why portals are different from snapshots: the source stays alive, updates in real time, and can be projected into overlays, lenses, reflections, or warped slices
• Just as important, it keeps the line clear between research and production: _UIPortalView is a fascinating private API to study, but not something to ship in an App Store build

Swift 6.4: What’s New In Concurrency

Antoine van der Lee’s overview is useful because it focuses on the small Swift 6.4 concurrency changes that are easy to miss, but likely to show up quickly in real code.

• The biggest additions include async defer, cancellation shields, async Result, typed throwing Task initializers, and warnings for ignored throwing tasks
• He also flags two changes that matter beyond pure concurrency syntax: weak let for cleaner Sendable code, and ~Sendablefor making intentionally non-sendable public types explicit

Coding 👨‍💻

Actors In Swift: The Problem They Solve And How It Works

Omar Elsayed breaks actors down from first principles, which makes this feel more like a mental model repair than just another concurrency explainer.

• It clarifies what actors actually protect, how cross-actor access works, and why await is required even for synchronous actor methods across isolation boundaries
• The most valuable section is reentrancy: actor calls are safe from data races, but state can still change across suspension points, and that is where the confusing bugs begin

SwiftUI’s New Item Based Presentations In iOS 27

Sagar Unagar highlights one of those SwiftUI changes that looks small, but quietly fixes a long-standing state smell.

• Alerts and confirmation dialogs can now be driven directly from optional item state
• That means no extra Boolean flags, fewer impossible states, and cleaner presentation logic

Apple 🍏

Updated Apple Developer Program License Agreement Now Available

Apple has revised Attachment 12 of the Apple Developer Program License Agreement to spell out terms for iOS apps in Brazil.

• The update covers alternative distribution, alternative payments, out-of-app offers, and the Core Technology Commission.
• Developers need to sign in and accept the new terms, while translated versions will appear on the Apple Developer website within a month.

Changes To iOS In Brazil

Apple is opening up iOS in Brazil under a new agreement with CADE, and the change is much bigger than a policy footnote.

• Starting with iOS 26.5, developers in Brazil can use alternative app marketplaces and external payment options for digital goods and services.
• Apple is pairing that with new safeguards like iOS notarization, marketplace authorization, and child-safety requirements, and developers must accept updated program terms by July 6, 2026

Design 🎨

WWDC26: SwiftUI Group Lab 2nd - Q&A

Article turns another dense SwiftUI lab into something you can actually come back to after WWDC.

• It covers practical SwiftUI topics like navigation, layout, geometry, identity, overlays, and UIKit interop.
• The big win is readability: grouped answers and time codes make the session much easier to revisit.

Liquid Glass In SwiftUI: How To Modernize An iOS App Template

Beniamin Marcu frames Liquid Glass as a structural redesign problem, not a quick visual polish pass.

• Start with navigation, surfaces, and shared components before touching colors
• The article also pushes a careful rollout: design tokens, system components where they help, layered icons, and small reversible updates

Other cool stuff 🧰

Swift Package Index Joins Apple

Ted Kremenek, Dave Verwer, and Sven A. Schmidt announce that Swift Package Index is now part of Apple, with the goal of building a more robust package registry for the Swift ecosystem.

• Swift Package Index will keep operating as it does today, with no immediate changes for package consumers or authors.
• Apple’s backing is meant to push things further in areas like scale, package signing, identity, and long-term ecosystem reliability.

Swift Conditionals: if, switch, guard and Pattern Matching

Divyesh Vekariya’s article is aimed at fundamentals, but it does a good job showing where Swift’s conditionals stop being familiar syntax and start becoming expressive language tools.

• It walks from optional binding into Swift’s much more powerful switch, including ranges, tuples, value binding, and whereclauses.
• The other big theme is guard: not just as syntax, but as a way to flatten functions and make preconditions obvious.

Tutorials 📒

How To Use Ollama Models In Xcode 27

Amos Gyamfi shows how Xcode 27’s new Chat Provider path opens the door to both local and cloud-hosted Ollama models inside the coding assistant workflow.

• The setup is straightforward for local models: install Ollama, run a model, then point Xcode’s locally hosted provider
• The article also covers the hosted route, where Ollama Cloud models are added through Xcode’s internet-hosted provider using an API key and standard auth headers

Video 🎥

Swift Macros Demystified: Build A Freestanding Expression Macro

Stewart Lynch takes one of Swift’s more intimidating features and makes it feel much more approachable by building a freestanding expression macro step by step.

• The video is focused on understanding, not just copying code
• It is a practical walk through of how macros expand and how to build one yourself

Watch here.📍Level: Intermediate

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 271

Wed, 17 Jun 2026 20:01:08 GMT

Weekly note ✏️

WWDC is calmly leaving us with a lot of new frameworks, reviews, and guides to explore. This year, however, felt different from previous conferences. There were no traditional one-on-one Labs, but plenty of group Labs. No dedicated app consultation appointments where you could discuss your product and ask for best practices tailored to your use case. The format is evolving, just like the industry itself.

Software development has changed dramatically over the last few years. Old habits, learning plans, and even tutorials become outdated faster than ever. Even the biggest companies are adapting to new realities. And it’s not only developers who face these changes. The tools we rely on have their own growing pains.

It was hard to find a developer community this week where Fable 5’s blocking policies weren’t discussed. From memes to deep technical analyses, everyone seemed to have an opinion on who might be affected and why. Combined with stricter token limits and changing subscription models across AI platforms, it raises an interesting question: will these restrictions accelerate the adoption of local open-source models?

Models like Qwen, Gemma, and others continue to improve, offering developers more control over privacy, costs, and availability. Running AI locally still requires hardware and setup, but the trade-off may become increasingly attractive as cloud services adjust pricing and usage policies.

One thing WWDC reminded us is that adaptation is part of our profession. Frameworks change, conferences change, AI tools change, and so do our workflows. The important part is staying curious and finding the right balance between shiny new technologies and practical everyday development.

Have you already tried a local LLM, and could you imagine it becoming part of your daily toolkit?

Swift Around the Web 🌐

(Some) Unanswered Swift Group Questions

Matt Massicotte picks up the Swift Group Lab questions that never made it onto the stage and gives them the kind of direct, experience-heavy answers many teams probably needed more than the live format allowed.

• Swift 6 defaults are powerful, but easy to misuse
• Matt’s answers are valuable because they show when defaults help and when nonisolated becomes necessary

WWDC26: Swift Group Lab – Q&A

Post turns a long live lab into something much easier to keep and reuse after WWDC.

• The Q&A covers real Swift pain points
• Grouped answers and time codes make it much easier to scan

Coding 👨‍💻

Async Cleanup In defer With Swift 6.4

Artem Mirzabekian highlights one of those language changes that looks small on paper but removes a very real annoyance from modern async code.

• defer can now contain await in Swift 6.4
• That makes async cleanup much cleaner around teardown, actor calls, and resource handling

Testing Foundation Models: Code That Won’t Give The Same Answer Twice

Wesley Matlock tackles the testing problem almost everyone runs into with on-device AI: the feature works, the code is covered, but the model itself sits outside the test strategy because its output refuses to stay still.

• The framework uses contract checks, mocks, and rubric-based evals
• Test shape and behavior first, then score model quality over time

Apple 🍏

Deprecation Of The ImageCreator Class

Apple is drawing a hard line around ImageCreator: the API is being discontinued and will stop working on iOS 27, iPadOS 27, macOS 27, and visionOS 27.

• Beta builds still compile, but warn in Xcode and fail in TestFlight
• Before release, apps need to move to Image Playground or another image service

New Domain For Sign In With Apple And iCloud+ Hide My Email

Apple is unifying relay email addresses under private.icloud.com later this summer, which means Sign in with Apple and Hide My Email will start generating new aliases on the same shared domain.

• Existing relay emails will keep working
• Developers should update allowlists and email validation rules for private.icloud.com

Design 🎨

SwiftUI’s New .prominent Tab In iOS 27 Is Not A Floating Action Button

Sagar Unagar makes a sharp design point that a lot of teams will probably need to hear during the iOS 27 cycle.

• .prominent highlights a destination, not an action
• If it opens a flow or sheet, it probably is not the right fit

Other cool stuff 🧰

Custom Scroll Layouts With Swipe Actions In SwiftUI On iOS 27

Natalia Panferova highlights one of those small WWDC additions that immediately removes a long-standing SwiftUI annoyance.

• swipeActions now works beyond List, including ScrollView layouts and custom Layout types
• onPresentationChanged helps track which row is currently open

What’s New In SwiftData For iOS 27

Mohammad Azam roundup is a good reminder that SwiftData did not get one giant headline feature this year — it got a set of fixes that make everyday modeling and querying feel much less awkward.

• iOS 27 fills in several long-missing SwiftData gaps
• The update reduces enum workarounds, custom filtering, and schema friction

WWDC26 Group Labs: The Real Story Isn’t Foundation Models. It’s Evaluation.

Divya Ravi’s piece pulls one idea out of multiple WWDC26 labs and makes it feel much bigger than any single framework announcement.

• OS-bundled models make evaluation a product requirement, not a nice-to-have
• Apple’s labs also exposed practical limits around context windows, routing, schemas, and prompt-injection risk

AI 🤖

Statement On The US Government Directive To Suspend Access To Fable 5 And Mythos 5

Anthropic says it was ordered by the US government on June 12, 2026 to suspend Fable 5 and Mythos 5 for all users, including foreign nationals inside Anthropic, while leaving other Anthropic models unaffected.

• Anthropic says the directive was based on a narrow jailbreak, not broad dangerous capability
• The company is complying, but warns this standard could chill frontier model releases

Tutorials 📒

Using Claude With Apple Foundation Models

Artem Novichkov shows how quickly Anthropic’s package turns Claude into a drop-in remote model for Apple’s Foundation Models API, so the same LanguageModelSession, @Generable, and tool-calling patterns can work with either on-device or server-side models.

• It covers real product tradeoffs like auth, model switching, and context limits
• It also shows where this is heading: one API, swappable models, and richer tool use

Video 🎥

Build a Swift Terminal Developer Toolkit with TUIkit

Stewart Lynch uses Tuikit to build a real multi-panel terminal app in Swift, not just a toy demo.

• The app combines navigation, persisted state, Git status, and a release tracker inside one terminal UI
• It also shows the full path to something usable: third-party packages, build steps, and installing the tool so it can run anywhere

Watch here.📍Level: Intermediate

Books 📚

Packt Publishing Sale

Packt Publishing is running a huge sale across many of its books, including “AI Driven Swift Architecture” by Walid SASSI and Dave Poirier.

If modern AI development sometimes feels like sailing through unpredictable seas, this book can serve as a lighthouse. It combines practical guides with real-world examples to help you understand AI tools, improve your workflow, and build better Swift applications.

Buy here.📍

The Founder’s Playbook: Building An AI-Native Startup

Anthropic’s playbook reframes the startup journey around what small teams can do when AI is baked into the company from day one, not bolted on later.

• It breaks the journey into Idea, MVP, Launch, and Scale
• The big shift is from building everything yourself to orchestrating AI-assisted work

Those Who Swift - Issue 270

Wed, 10 Jun 2026 20:40:29 GMT

Weekly note ✏️

It’s easy to write a note this week because… you know why. It’s WWDC week!

Whether you’re attending in person or, like most of us, following online, this is one of the most exciting periods of the year for Apple developers. There’s also a touch of history to it. Many expect this to be Tim Cook’s last WWDC as Apple’s CEO, making the event even more memorable. Whatever the future holds, the technologies presented this week will shape our work for years to come.

To make the most of the conference, here are a few tips:

• Start with the Keynote and the Platforms State of the Union. The Keynote gives you the big picture, while the State of the Union dives into the technical details and often reveals features developers care about the most.

• Bookmark the sessions you’re most interested in and watch them at your own pace. A few years ago, Apple started releasing almost all videos on Day 1, so you no longer have to worry about booking a lab before seeing the related session.

• Don’t skip the Labs! They’re one of the best opportunities to ask Apple engineers direct questions in a more informal setting. Sometimes a five-minute conversation can save hours of debugging.

• Rewatching is absolutely encouraged. If a concept doesn’t click during the first viewing, don’t worry. WWDC content ages well, and you can always return to it weeks or even months later when you need it.

A comfortable pace is probably the best WWDC strategy. There’s no prize for watching every session in a single week, and a healthy sleep schedule will help more than another late-night video marathon.

The reward is worth it. Every year we discover new techniques and fresh approaches to code we use every day. This year is no exception. Even familiar concepts like task cancellation received thoughtful improvements, including new cleanup capabilities for concurrent tasks.

Enjoy the conference, take notes, ask questions, and remember: WWDC is not a sprint but a library you can keep returning to throughout the year.

What is the one announcement that would make your WWDC unforgettable?

Swift Around the Web 🌐

iOS 27: Notable UIKit Additions

Jordan Morgan rounds up this year’s UIKit changes with a clear pattern: most of the work is not flashy, but aimed at adaptable navigation, scene management, and tab or sidebar behavior in a more multi-window, resizable world.

What Is New In SwiftUI After WWDC26

Majid Jabrayilov’s WWDC26 SwiftUI roundup feels refreshingly grounded: not a reinvention of the framework, but a steady removal of real production pain points around containers, navigation, toolbar control, and document workflows.

SwiftUI’s State Is Now A Macro

Artem Mirzabekian explains that Apple has changed @State under the hood from a property-wrapper presentation to a macro-based one, without changing the way SwiftUI code is written day to day.

Coding 👨‍💻

What’s New In Swift: May 2026 Edition

Dave Lester’s monthly Swift digest works best as a quick radar sweep rather than one big headline, pulling together meetup talks, WebAssembly progress, mentorship news, notable package releases, and a few Swift Evolution updates worth tracking.

Announcing The Networking Workgroup

Swift’s Ecosystem Steering Group has created a new Networking workgroup to push the platform toward a more unified and interoperable networking stack, from low-level I/O and shared protocol implementations up to modern client and server APIs.

SwiftUI: Observable Macro Under The Hood

Nikita Vasilev unpacks @Observable by showing that it is not just nicer syntax, but a compile-time transformation that rewrites stored properties, injects an ObservationRegistrar, and tracks reads and writes at the key-path level.

Apple 🍏

Introducing Time Allowances

Apple is adding Time Allowances in iOS 27, iPadOS 27, and macOS 27 so parents can manage kids’ app time more flexibly across categories like Entertainment, Games, and Social Media. For developers, the part to watch is classification: social features will soon need to be declared in the age rating questionnaire, can trigger a 13+ minimum age rating, and become a required disclosure for new submissions and updates starting in September 2026.

Updated Apple Developer Program License Agreement And App Review Guidelines Now Available

Apple has revised both the Apple Developer Program License Agreement and the App Review Guidelines to cover new frameworks, updated AI terms, kid and teen safety guidance, and a handful of policy clarifications across areas like Live Activities, accessibility-related content changes, and developer identity requirements. This one is worth skimming even if you usually ignore agreement updates, because the changes touch practical areas such as Foundation Models, Trust Insights, Suggested Actions, Customer Engagement APIs, App Store Connect disclosures for minors, and stricter wording around spam or phishing through Live Activities

Update For Apps Distributed In Texas

Apple says new Apple Accounts in Texas will start falling under SB 2420 on June 4, 2026, which means age assurance, parent or guardian consent for minors under 18, and support for consent revocation now matter for downloads, in-app purchases, and significant app changes. For developers, this is less a policy footnote than an integration checklist: review the Declared Age Range API, PermissionKit’s Significant Change API, the new StoreKit age rating property, and the related App Store server notification flow.

Apple Developer Centers Are Expanding To Berlin

Apple is opening its fifth Developer Center in Berlin later in 2026, giving developers across Europe closer access to in-person sessions, workshops, labs, and one-on-one appointments with Apple experts. The post reads less like a product announcement and more like an ecosystem investment, especially with multilingual support and hands-on consultation spaces built into the new center.

Design 🎨

SwiftUI Animation Timing

Natalia Panferova breaks SwiftUI animation timing into three layers — easing curves, spring animations, and fully custom timing — and explains them in a way that makes the presets feel much less like magic.

Other cool stuff 🧰

What We Learned Hitting #1 on Product Hunt

Philip Sørensen, Co-founder & CEO of Brew, shares how they hit #1 on Product Hunt and what lessons they picked up along the way. Also what surprised him and the one thing he wishes someone had told him before launching.

Styling Measurement Unit Fonts In SwiftUI

Natalia Panferova shows a neat way to style the value and unit of a formatted Measurement differently in SwiftUI by using AttributedString instead of treating the whole output as one uniform Text.

AI 🤖

Claude Fable 5 and Claude Mythos 5

Anthropic is drawing a sharper line between broad access and frontier capability here, releasing Claude Fable 5 for general use while keeping the less-restricted Mythos 5 behind trusted-access programs for cyberdefense and life sciences.

Master Of Puppets: Foundation Models Tool Calling In Swift

Wesley Matlock shows how Apple’s on-device model can stop guessing and start asking your app for facts mid-generation by calling Swift tools inside a single respond flow. The article becomes much more than a framework tour once it reaches the real constraints: SwiftData isolation, Sendable boundaries, actor-owned stores, and the surprisingly important detail that tool results should come back as readable ground truth, not just raw structured blobs.

Tutorials 📒

SwiftUI Localization Guide — Change Language Without Restarting The App

Sagar Unagar shows how to make in-app language switching feel truly native in SwiftUI, with instant updates, persisted selection, and proper RTL support instead of sending users to Settings and forcing a relaunch.

Video 🎥

WWDC26: Keynote

Apple’s WWDC26 keynote is the broadest possible reset, with the official chapter list pointing to four big beats: platform improvements, trust and safety, Apple Intelligence and Siri, and the usual sweep across the latest software releases. It is less of a deep technical session than a map of the year ahead, so its real value is in showing where Apple wants developer attention to go before the detailed platform talks begin.

Watch here.📍

WWDC26: Platforms State Of The Union

Apple’s companion session to the keynote is the developer-facing version of the week, framed around “the newest advancements on Apple platforms” rather than big public-facing announcements. In practice, this is usually the talk that matters more once the keynote ends, because it points developers toward the APIs, platform changes, and technical direction that will shape the rest of WWDC26.

Watch here.📍

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 269

Those Who Swift — Wed, 03 Jun 2026 20:25:32 GMT

Weekly note ✏️

Anthropic has confidentially filed for an IPO that could bring the company to the public market as early as this fall. OpenAI is reportedly moving in the same direction. Looks like this year will become one of the biggest for AI-related IPOs and investments. The race is no longer just about models and benchmarks. It’s about infrastructure, profitability, market positioning, and who will shape the next generation of tools developers use daily.

And meanwhile, we are preparing for WWDC.

Apple has already released its intro video, mentioning Labs, popular sessions, and even music. Yes, WWDC has its own official Apple Music playlist, and surprisingly BTS made it there too. The conference keeps evolving from a purely technical event into a full ecosystem experience around development and creativity.

Last week’s poll showed fairly predictable but very realistic expectations from developers: a more stable Xcode with fewer crashes, smarter predictions that actually work as intended, and deeper UIKit adaptation of controls and features for SwiftUI. Many developers still feel that SwiftUI lacks parity in important areas, especially for complex production apps.

Hopefully next week will show whether these expectations are finally met.

And to demonstrate how inspiring WWDC can be, in collaboration with TheSwiftVlad we’re sharing a beautiful SF Symbols animation. Because honestly, wouldn’t it be great to see this level of polish and creativity presented directly during the conference itself?

What is the one WWDC announcement that would instantly make your daily development workflow better?

The AI Agent for Your RevenueCat Data

Meet Rico! 👋

RevenueCat's embedded AI app growth advisor for subscription apps. Ask questions about churn, trials, pricing, paywalls, or retention and get answers using your app's real subscription data directly inside RevenueCat and Slack.

Built to help iOS developers make smarter monetization decisions faster.

Try Rico today!

Swift Around the Web 🌐

Stateless Actors

Matt Massicotte explores a deceptively simple question: if actors exist to protect mutable state, does an actor with no state make any sense at all? His answer is more nuanced than a yes or no, showing that stateless actors can still be useful for off-main execution, custom executors, or protecting external state like the file system — but only when the trade-offs are clearly understood.

Task Names In Swift Concurrency

Artem Novichkov walks through Swift’s new task naming support and shows why it matters once concurrent work gets large enough to debug, profile, or inspect in Instruments. A nice detail in the article is that names are meant for diagnostics, not app logic, with clear examples across Task, detached tasks, task groups, SwiftUI’s .task, and the current limitation that async let children still cannot be named.

Coding 👨‍💻

How Do You Build A Mutex That Works With Async/Await?

Omar Elsayed explores a subtle concurrency problem: actors do not guarantee mutual exclusion across suspension points, and Swift’s native Mutex cannot safely span await. The article gets especially interesting when it breaks down Matt Massicotte’s TaskGate approach, using continuations and a small internal lock to hand ownership from one waiting task to the next without blocking cooperative threads.

Registering For Push Notifications In SwiftUI

Natascha Fadeeva walks through the full push registration flow in SwiftUI, from requesting permission and checking the current authorization state to registering with APNs and handling the returned device token. A useful reminder here is that SwiftUI still relies on an app delegate for the APNs callbacks, so UIApplicationDelegateAdaptor remains part of the picture even in a modern app.

Apple 🍏

All Systems Glow

Apple is using this short post as another WWDC26 countdown marker, with the conference now just one week away and the full event staying online and free. This is more of a mood-setting signal than a product update, but it does mark the final stretch before the June 8, 2026 kickoff.

Get Ready With The Latest Beta Releases

Apple has released new beta builds for iOS 26.6, iPadOS 26.6, macOS 26.6, tvOS 26.6, visionOS 26.6, and watchOS 26.6, alongside the recommendation to build and test with Xcode 26.5. It is the usual signal to start validation early, especially if your app depends on newer SDK behavior or platform-specific edge cases.

Design 🎨

Building For Voice In, Visuals Out

Allen Pike argues that AI is moving toward a more natural interaction pattern where people speak and computers respond with interfaces, visuals, and structured output instead of long spoken replies. What makes the piece stand out is its focus on latency: voice feels magical only when it is fast enough to avoid awkward turn-taking, which is why voice-in and visuals-out may be the most practical near-term direction for real products.

Other cool stuff 🧰

Marketing Apps as a Developer

Oleh Stasula, the founder of WinWinKit and Usage is coming back for the part 2. In the part 1 he shared a few personal tips on how he designs apps users love.

This is part 2 - about what to do once you’ve shipped, because shipping without marketing will keep your product invisible.

Reactive Frameworks Vs Async/Await Vs AsyncAlgorithms

Artem Mirzabekian looks at the shift in Swift’s center of gravity: reactive frameworks once gave iOS developers one clean model for asynchronous code, but async/await, actors, Observation, AsyncSequence, and AsyncAlgorithms now cover most of that ground with less conceptual weight.

Scaling iOS Application Development With Tuist

Michael Gerasymenko and Ashutosh Dubey show how Delivery Hero used Tuist to keep Xcode and Swift Package Manager in place while making a fast-growing modular codebase much easier to scale. The numbers make the story land: local clean builds dropped from 2.5 minutes to 0.5 minutes, incremental builds roughly halved, and CI build plus unit-test time improved by 2.5x — with the trade-off being migration effort, caching-related debugging limits, and the discipline needed to maintain project structure as code.

AI 🤖

Enter Sandman Mode: Three Months Inside Xcode 26.3’s Agentic Coding

Wesley Matlock treats Xcode 26.3’s agentic coding less like magic and more like a sharp new tool: excellent at grounded multi-file refactors, compiler-driven fix loops, and SwiftUI preview iteration, but still prone to losing the thread or inventing neat-looking abstractions that do not belong.

Tutorials 📒

Enabling Haptic Feedback With `sensoryFeedback` In SwiftUI

Gabriel Theodoropoulos shows how SwiftUI’s sensoryFeedback modifier makes haptics feel like a natural part of view code, with semantic styles like selection, success, error, start, and stop, plus custom impact variations when more control is needed. The article is especially helpful in the way it explains the trigger model: feedback is tied to changes in an Equatable value, not to the button tap itself, which is an easy detail to miss at first.

Video 🎥

Apple’s Hidden AI: Unlock Foundation Models on Your Mac with Apfel

Stewart Lynch turns Apple’s on-device models into something much more tangible by using Appfel from Terminal instead of starting with a full Xcode project. The video gets even more practical in the second half, where he installs it with Homebrew, tries prompt, chat, and server modes, then uses agentic coding to reshape an existing Appfel-based Mac utility into something that better fits his workflow.

Watch here.📍Level: Advanced

Modern iOS Security: Attacks, Defenses & AI

This Swift Academy episode turns iOS security into a very current discussion, mixing real production failures with a broader look at how AI is changing both attack speed and defense workflows. Conversation with Dave Poirier and Deya Elkhawaldeh is especially valuable because it stays practical: weak storage, unsafe assumptions about “secure by default” platforms, and shallow threat modeling are still common, while AI is rapidly lowering the barrier for reverse engineering and automated security review.

Watch here.📍Level: Advanced

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 268

Wed, 27 May 2026 20:55:52 GMT

Weekly note ✏️

WWDC is getting closer and closer, and this time it feels less like gentle notification sounds and more like a huge bell ringing about upcoming changes. AI Agent videos are already appearing outside the usual WWDC flow, leadership changes are making headlines, and many are even speculating that this could be one of the last conferences where Tim Cook still takes such a central role on stage.

Of course, Apple is presenting technologies that have been in development for years, not just between conference cycles. Whatever we see this June will continue shaping the ecosystem for many years ahead. That’s why this period always becomes the season of wishlists. Developers start sharing hopes for iOS, visionOS, tvOS, Swift, Xcode, and everything around them. Better multitasking, smarter Siri, more open frameworks, improved AI integrations, fewer restrictions, and more stability.

One topic that keeps surfacing again and again is SwiftUI. Despite all the progress, many developers still struggle with hidden behaviors, unpredictable rendering, navigation edge cases, and debugging complexity. Discussions around “SwiftUI should become open source” appear more frequently every year. Not because developers dislike the framework, but because they want to understand it better, contribute fixes faster, and build more predictable architectures on top of it. Swift itself became stronger after opening up to the community, and many wonder whether SwiftUI could benefit from the same path.

But expectations are tricky things. The lower they are, the easier it is to be surprised in a good way.

So instead of asking about cold expectations, let’s ask something different: what change would genuinely make your everyday development experience better?

Justas here… 🙋‍♂️

I would like to share something you might find valuable.

My friend Simonas and I launched a 100% FREE invoicing tool called - Invcly

Nothing super fancy, just a simple invoicing tool that allows you to send and track invoices. The main reason we built it is because I was tired of paying $20 a month for invoicing software, paying extra for features, for more saved clients, and other upsells. Companies always find ways to charge you more.

With Invcly, you can:

📌 Create and track invoices.
📌 Save clients.
📌 Create and save templates.
📌 Send recurring invoices (still in beta).
📌 Create different products.

And most importantly, it’s always FREE. No hidden fees or hard paywalls (you know what I’m talking about).

Feel free to use it, share it with friends, and most importantly, send me an email with any bugs or features you would like to see.

Enjoy, and let’s make invoicing simple and free! 🧾

Try Invcly!

Swift Around the Web 🌐

Swift Task Lifecycle Management - Structured vs Unstructured Concurrency

Sagar Unagar shows why concurrency structure in Swift is not just a style choice, but something that directly affects task lifetime, cancellation, error propagation, and UI consistency. His guidance is refreshingly clear: start with structured tools like async let, TaskGroup, and SwiftUI’s .task, and only move to unstructured Task or Task.detached when the work is genuinely independent.

UniqueBox, Ref, And MutableRef In Swift 6.4

Artem Mirzabekian explores how Swift 6.4 expands the language’s ownership vocabulary with UniqueBox, Ref, and MutableRef, giving developers more precise tools than class boxes or unsafe pointers for expressing heap ownership and scoped access. A useful way to read this addition is as a split between storage and access, which makes these types especially relevant for lower-level libraries, custom storage, interop layers, and performance-sensitive code.

Coding 👨‍💻

Making A SwiftUI Sheet Automatically Size To Fit Its Content

Daniel Saidi shows a neat workaround for one of SwiftUI’s missing sheet features: sizing a sheet to its actual content instead of forcing it into .medium, .large, or a guessed fixed height.

Working With The Keychain In iOS

Natascha Fadeeva explains the Keychain through its core query model, showing how the same dictionary-based structure powers save, read, update, and delete operations for sensitive data like passwords and tokens.

Refreshing And Animating Views Using TimelineView In SwiftUI

Natalia Panferova shows how TimelineView gives SwiftUI a clean way to reevaluate views on a schedule, which makes it especially useful for clocks, timed refreshes, and visuals that need to stay in sync with time. A helpful distinction in her article is that TimelineView belongs to the UI layer, while Timer is still the better fit for background work, data refreshes, or logic that should live outside the view.

Apple 🍏

Upcoming Changes To Age Ratings In Australia And Vietnam

Apple is updating App Store age ratings in Australia and Vietnam on June 18, 2026, with Australia dropping the 15+ category and Vietnam introducing local age ratings aligned with national law. The key thing for developers is to revisit the App Store Connect age rating questionnaire now, since existing ratings may be recalculated automatically from the answers already on file.

Design 🎨

Making Accessibility Accessible

Bas Broek lowers the barrier to accessibility work by focusing on practical tools like Voice Control labels, Hover Text, and the VoiceOver caption panel instead of starting with deep theory. The most useful takeaway is that accessibility becomes easier to improve when teams can quickly see what assistive technologies expose and spot where labels, traits, or element exposure break down.

Other cool stuff 🧰

Modern Isn’t A Value. Fit Is.

Omar Elsayed argues that “modern” APIs like async/await, actors, or new architectures are not automatically better when they make the surrounding codebase harder to read and integrate with. The most useful takeaway is the boundary rule: modernize internals when it helps, but keep external APIs aligned with the system your team already speaks.

In Praise Of SwiftUI

SwiftUI’s biggest win may not be “UI in Swift” at all, but the reactive data flow that keeps complex interfaces in sync without so much manual plumbing. Sarah Reichelt makes a grounded case for treating it as the default choice for speed and maintainability, then reaching for AppKit or UIKit only when a real gap, bug, or performance limit shows up.

SwiftUI Should Become Open-Source

Max Seelemann argues that SwiftUI still struggles with core platform behaviors like keyboard focus timing and macOS drag and drop, which makes Apple’s “best way to build an app” promise harder to defend. His bigger point is that open-sourcing SwiftUI could speed up fixes, reduce its dependence on OS release cycles, and give developers a way to help move the framework forward where Apple has been too slow.

AI 🤖

Anthropic Co-Founder Chris Olah’s Remarks On Pope Leo XIV’s Encyclical “Magnifica Humanitas”

Chris Olah argues that AI should be examined not only by the labs building it, but also by outside critics willing to question its broader social and moral impact. He centers that case on three concerns in particular: global inequality, human flourishing, and how little we still understand about advanced models, while candidly noting that commercial and geopolitical pressure can push frontier labs away from acting responsibly.

Tutorials 📒

Create And Style App Shortcuts In iOS Using AppShortcutsProvider

Shankar Madeshvaran walks through the full App Shortcuts flow, from AppIntent and AppShortcutsProvider setup to branded tiles with custom tint, solid backgrounds, gradients, and Light/Dark variants. Shortcut styling lives in Info.plist and asset catalogs, not Swift code, and the same branded look also carries into Spotlight results.

Video 🎥

Decoupling SwiftData in SwiftUI: Is It Worth It?

Mohammad Azam uses a practical SwiftData and SQLite example to show how a protocol-based DataAccess layer can decouple persistence from SwiftUI views, while also exposing the real cost of that abstraction. This pattern gives flexibility and cleaner boundaries, but you lose SwiftData conveniences like automatic UI updates and can end up with more architectural weight than the app really needs.

Watch here.📍Level: XXX

One more Thing 🎮

W.W.D.C. 2026: The Pregame Quiz

Jordan Morgan turns pre-WWDC nerves into a smart trivia round built from the year’s Apple news, App Store policy updates, hardware launches, and community lore. It works as more than a quiz, really — a fun way to refresh the details developers are most likely to want in their heads before the keynote.

Play here.📍

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 267

Those Who Swift — Wed, 20 May 2026 20:01:12 GMT

Weekly note ✏️

Hello! 👋

This week I partnered with Shannon Ash. She’s been writing CVs since COVID-19 hit, helping people position themselves better and land new jobs.

Six years later, her work is still producing real results.

Some results:

87% of her clients landed interviews within 2 weeks of applying.
70% reported a salary increase, up to 35%, while securing their new role.
Some went from months, up to 4 months, of silence to multiple offers at once.

Here are few testimonials:

The clients she mainly works with are usually dealing with one of these problems:

Ghosted - they’ve been applying for 2+ months with zero replies and no interviews.
Pivoting their career - they’re in their late 30s or 40s with a decade of expertise, but don’t know how to translate their wins or skills into a new industry or niche.
Aspiring to be a leader - they’re aiming for the C-Suite or a Senior Lead role, but their current CV still looks like a list of tasks, not a record of impact. The CV changes with seniority.
Procrastinating daily - they’re unhappy where they are, but the mental weight of updating their CV is a lot. They keep putting it off and don’t have the time to even start.

Offer:

Cover Letter and CV: a positioning statement letter, which is Shannon’s spin on a cover letter, plus a CV.
Fully optimized LinkedIn profile to match the new narrative.

Price: 450€ 📌

Important - this offer has limited spots:

June only 5 spots available.
July only 5 spots available.
August only 10 spots available.

Interested? - Just reply to this email or contact me at - thisweekinswift@gmail.com

Swift Around the Web 🌐

Deprecating Your Own Convenience API

Majid Jabrayilov shows a neat way to stop compatibility helpers from becoming permanent dead code using Swift availability annotations. The key idea: deprecate wrappers when the new minimum OS makes them unnecessary, then obsolete them later so the compiler forces cleanup.

A Feature Flags System In Swift

Artem Mirzabekian shows how feature flags can grow from simple booleans into real app infrastructure while staying type-safe, thread-safe, and predictable. The most useful part is the full architecture: typed features, priority-based resolution, local overrides, SwiftUI environment injection, and a built-in toggle screen for QA and testing.

Coding 👨‍💻

Tracking App Store Purchases With Server Notifications

Mohammad Azam shows how App Store Server Notifications complete the StoreKit 2 story by letting your backend react to renewals, refunds, billing issues, expirations, and purchases outside the app. The most useful part is the payload breakdown: Apple sends nested signed JWTs, so the key is decoding signedPayload, then signedTransactionInfo and signedRenewalInfo, to extract transaction and renewal state cleanly.

ContentUnavailableView In SwiftUI - Complete Guide With Examples

Sagar Unagar shows why ContentUnavailableView is more than a simple empty-state helper: it gives SwiftUI apps a consistent, accessible way to handle no-content, failed-load, and no-results screens without rebuilding the same UI each time. The most useful part is the practical range, from the built-in .search variant to custom actions and recovery flows, while keeping empty states restrained and platform-native.

Apple 🍏

Coming Bright Up - WWDC26

Apple is teasing WWDC26 with a short preview, calling it a week of technology, creativity, and community that will be online and free. It is more of a save-the-date than a technical update, but confirms Apple is starting the WWDC ramp-up.

Introducing The 2026 Apple Design Award Finalists

Apple has announced the 2026 Apple Design Award finalists, highlighting 36 apps and games for innovation, ingenuity, and technical achievement. It is a good shortlist to browse before WWDC, especially for a quick look at the product quality and design direction Apple is celebrating this year.

Other cool stuff 🧰

Using Xcode MCP With Claude Code

Daniel Saidi shows how Xcode 26.3’s built-in MCP server gives Claude Code direct awareness of project structure, schemes, builds, and tests instead of treating Swift files as isolated text.

Understanding Basic Animations In SwiftUI

Natascha Fadeeva explains the two core SwiftUI animation paths: animation(_:value:) for view-driven implicit animation and withAnimation for explicit state-driven changes. The most useful part is the decision guide, including when to use each approach and the iOS 17+ completion handler for follow-up work after an animation finishes.

AI 🤖

How Claude Code Works In Large Codebases: Best Practices And Where To Start

Anthropic says Claude Code works best in large codebases when teams invest in the harness around the model, especially CLAUDE.md files, hooks, skills, plugins, LSP integrations, MCP servers, and subagents. The most useful takeaway is practical: live agentic search avoids stale indexes, but results improve when the codebase gives Claude clear local context and path-specific expertise.

Tutorials 📒

How To Recognize Text In Images With Vision In Swift

Khoa Pham shows how Apple’s newer Vision API makes text recognition cleaner by replacing callback-heavy VNRecognizeTextRequest flows with the async RecognizeTextRequest introduced in iOS 18 and macOS 15. The key takeaway: avoid fragile continuation wrappers around the older synchronous API, and use the new async request model when your deployment target allows it.

Optimizing For VoiceOver And Voice Control

Bas Broek shows how an accessibility change that feels cleaner for VoiceOver can make Voice Control noticeably worse, especially when combined elements turn separate buttons into hidden actions. The key takeaway: improving one assistive technology can hurt another, so the better solution is sometimes the more balanced one, not the most “optimized” version.

Video 🎥

Understanding Swift Result Builders-The Power Behind ViewBuilder

Stewart Lynch starts with ViewBuilder in familiar SwiftUI containers, then builds custom result builders from scratch to show how declarative syntax works under the hood. The most useful part is the hands-on progression from simple string builders to conditional checklist generation with buildExpression, buildOptional, and buildEither.

Watch here.📍Level: Intermediate

Claude Code Just Dropped /Goal (Master It In 8 Minutes)

This walkthrough explains /goal as a hands-off Claude Code workflow, where one model does the work and a second agent checks whether the finish line has been met. The key takeaway: goal conditions should be specific and verifiable, with turn or time limits to avoid wasted tokens.

Watch here.📍Level: Beginner

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 266

Wed, 13 May 2026 20:01:18 GMT

Weekly note ✏️

Apple recently shared a list of authors and content creators who are shaping and supporting the iOS community. 👏

From meetup organizers to developers publishing valuable tutorials, tips, and deep dives, this recognition highlights something important.

First, it shows that platform owners fully understand one thing: the ecosystem cannot exist without the people actually building apps and sharing knowledge outside official events like WWDC or Meet with Apple sessions. Learning never stops at documentation. Development moves too fast for that. New frameworks, APIs, architectural patterns, and tools appear constantly, and staying up to date means following many different voices and perspectives. In a way, Apple has created its own watchlist of creators worth paying attention to.

Second, this kind of recognition is genuinely inspiring for authors themselves. More visibility means more readers, more feedback, and more motivation to continue. Consistently creating educational content is a skill polished over years. It takes time, energy, research, editing, and persistence. And knowing that your article, video, or podcast helped someone solve a problem or understand a difficult concept is often what keeps creators going.

Because even the most experienced developers can still pause at subtle details, especially in areas like testing architecture or dependency isolation. That’s why this week we’re sharing a note about Stubs and Mocks.

What learning resource or creator has influenced your development journey the most?

Cut Your Swift Compile Times with Xcode 26

Xcode 26's compilation cache reuses outputs like object files and module artifacts when inputs don't change.

Bitrise was first to support it and saw 19-55% faster builds in testing. The Bitrise team walks through setup and what to expect as it matures.

Check out the webinar

Swift Around the Web 🌐

Accelerate Framework In Swift - Complete Guide To High-Performance Computing

Sagar Unagar shows why Accelerate is still one of Apple’s most underused frameworks, especially when naive loops start hurting apps that process signals, images, matrices, or large numeric datasets. The most useful part is the practical breakdown of vDSP, vForce, and BLAS, showing how vectorized system routines can replace manual iteration with code that is both clearer and dramatically faster.

How To Think About Performance In iOS

Artem Mirzabekian frames performance as a layered system, where perception, metrics, architecture, UI updates, networking, caching, scheduling, memory, and hardware all shape whether an app feels fast. The most useful takeaway is his order of attack: start with user-visible pain and measurement, then cut unnecessary work before reaching for low-level optimizations.

Coding 👨‍💻

Formatting Values In SwiftUI Text And TextField

Gabriel Theodoropoulos shows how SwiftUI’s format styles make Text and TextField much more powerful for numbers, percentages, currencies, and dates without manual string conversion. The most useful part is the input side: formatted TextField initializers can enforce valid numeric values automatically, while the stored type still controls how strict the field behaves.

SwiftUI: @State Under The Hood

Nikita Vasilev explains why @State survives view redraws even though SwiftUI views are value types: the real data lives outside the struct in SwiftUI’s long-lived Attribute Graph. The most useful part is the mental model shift, because it clarifies why @State should stay private, why init-based seeding often fails after first render, and how dependency tracking drives precise invalidation.

Apple 🍏

Brazilian Betting License Requirement For App Store Availability

Apple says fixed-odds betting apps can now be distributed on the App Store in Brazil, but only with a valid fixed-odds betting license from Brazil’s Secretariat of Prizes and Bets. The key practical detail is that developers must submit a new app version to start license verification, and answering “Yes” to the gambling question in App Store Connect sets the Brazil age rating to A18.

End-To-End Encrypted RCS Messaging Begins Rolling Out In Beta

Apple says end-to-end encrypted RCS is starting to roll out in beta for iPhone users on iOS 26.5 with supported carriers and Android users on the latest Google Messages. The most important user-facing detail is the new lock icon in RCS chats, with encryption enabled by default and expanding automatically to both new and existing conversations.

Other cool stuff 🧰

The CTO’s Incoming Storms

Etienne de Bruin maps six pressure points landing on CTOs right now, from AI-driven headcount cuts to board-level demands for an “AI strategy,” and argues that facts alone are no longer enough. The sharpest takeaway is to show up with a position built around trade-offs and business language, not a defensive technical rebuttal.

Finally Found A Use Case For .fixedSize

Omar Elsayed shows a neat SwiftUI layout trick where .fixedSize keeps an HStack inside a horizontal ScrollView only as tall as its tallest card, instead of expanding to the full screen.

AI 🤖

AI: When The More Rigorous Process Shipped The Lower-Quality Code

Dave Poirier compares two AI-assisted implementations of the same iOS telemetry feature and finds that the messier human-in-the-loop branch beat the stricter PRD-plus-TDD branch on testing depth, observability, and threading correctness. The sharpest takeaway is that spec-first AI workflows can stay too trapped inside their own frame, so production work still needs a separate pass for scope, integration edges, and operational gaps.

Agent View In Claude Code

Anthropic introduces agent view as a single place to manage multiple Claude Code sessions, with a list that shows which agents are waiting, still running, or finished. The most useful part is the workflow gain: you can background sessions, peek at the latest turn, reply inline, and jump between concurrent agents without juggling terminal tabs.

Tutorials 📒

SwiftData for Beginners

You will learn SwiftData through a small real app, starting from model design, source control, and local storage before moving into posts, images, navigation, and modern iOS 26 patterns. The most useful part is the beginner-friendly progression, where concepts like @Model, classes vs structs, optionals, and test data are introduced in the context of shipping an actual app.

Watch here.📍Level: Beginner

Video 🎥

Production SwiftUI: Scalable Networking Architecture With Async/Await And Generics

Karin Prater builds a reusable SwiftUI networking stack around services, endpoints, dependency injection, and concurrency-aware separation between UI state and background work. The most useful part is the architectural framing: keep observables focused on main-actor UI state, move fetch logic into sendable services, and use protocols plus mocks to make previews and scaling much easier.

Watch here.📍Level: Intermediate

Friends 🤝

Get 20% off Natalia Panferova’s “The SwiftUI Way“ book. Avoid SwiftUI anti-patterns that hurt stability and performance, while learning the recommended patterns and real-world trade-offs needed to scale production apps.

Discount code: ThoseWhoSwift

Download it HERE.📍

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 265

Wed, 06 May 2026 20:32:23 GMT

Weekly note ✏️

AI is not only changing how we write software, but also how we get hired!

We all know about ATS systems scanning résumés and filtering candidates before a human even sees the application. But hiring automation is going much further now.

For years, some companies used prerecorded interview questions where candidates recorded answers by pressing a button. Later came the “tell us about yourself” intro videos to evaluate communication skills and readiness for remote work.

Now some AI-first companies are fully automating the interview process itself.

Imagine an AI interviewer. Let’s call her Clara. She starts politely with an ice-breaker like “How’s your day going?” and then moves into structured sections: Swift, APIs, Xcode, architecture. Sounds futuristic until the details appear. Clara asks candidates to leave a two-second pause after each answer so the system can detect when speech ends. Think too long, pause dramatically, or hesitate naturally, and your answer might simply get cut off.

Have a noisy environment? Better warn the birds outside, the construction workers nearby, or anyone making unexpected sounds. The system may interpret any loud noise as the end of your response. And Clara will not repeat questions, no matter how many times you ask.

Then comes the final stage: screen sharing and a coding challenge, often with strict instructions not to use AI tools. Which sounds ironic considering the company itself is using AI to evaluate and filter candidates from the very beginning.

Maybe that’s the strangest part of all. The process is optimized for efficiency, but in doing so it often removes the human side entirely. Instead of building interest in the company, it can have the opposite effect. Less time invested in candidates, more restrictions, more automation.

At this point, the real question almost sounds inevitable: will AI soon be interviewing AI?

Have you had any similar experience lately, where you were interviewed by AI? 🤖

Share it in the comments. We would love to discuss! 💬

Forget about Ruby and Fastlane installation issues!

Discover Codemagic CLI tools — the free, open-source Fastlane alternative for automating iOS builds, code signing and publishing.

open GitHub

Swift Around the Web 🌐

Actors Vs Queues Vs Locks In Swift

Artem Mirzabekian compares three synchronization tools through the same lens: actors give the safest model for shared mutable state, queues fit older GCD-style coordination, and locks still matter when you need the lowest overhead. The most useful part is the tradeoff framing, because the right choice depends less on style and more on isolation needs, legacy code, and performance pressure.

Swift Concurrency: One await, Two Actors: A Runtime Trace

Nikita Galaganov explains what actually happens at runtime when Swift crosses an await, focusing on executor identity, suspension, continuation state, and executor hops between actors. The most useful part is the performance angle: the article shows that await is not just syntax sugar, and that understanding hop decisions matters when concurrency code runs at SDK scale across millions of devices.

Coding 👨‍💻

3 Key Strategies To Make SwiftUI Views More Reusable

Matteo Manferdini argues that most SwiftUI reuse problems start with monolithic views, then breaks the fix into three layers: extract small subviews, move shared styling into ViewModifier, and use generic container views when structure stays the same but content changes. The sharpest takeaway is his warning against computed properties as fake reuse, because they hide complexity inside the parent instead of creating truly testable, previewable, standalone components.

Scheduling And Handling Background App Refresh In SwiftUI

Natalia Panferova shows how to wire background refresh into a SwiftUI app with BGAppRefreshTaskRequest and the backgroundTask(_:action:) modifier, including the required capability and setup. The most useful reminder is that background refresh is opportunistic, not guaranteed, and should stay short-lived, with longer work pushed to other background APIs.

Design 🎨

Designing Beautiful Apps as a Developer - Part 1

Oleh Stasula is the founder of WinWinKit and Usage is haring a few personal tips on how he designs apps users love.

This is part 1. Part 2 will be live in a couple of weeks.

Subscribe to Indie App Devs!

Other cool stuff 🧰

Managing Personal Projects With Agents

Felix Krause shows how personal AI agents can turn scattered project inputs from email, chat, and files into a cleaner system built around structured notes, linked source documents, and controlled automation. The most useful idea is the safety-conscious workflow: only manually approved inputs get processed, while the agent updates notes, organizes Google Drive files, and surfaces the latest version fast when you actually need it.

AI 🤖

AI Doesn’t Remember Your Project, Markdown Does

Alejandro makes a practical case for writing project context down in Markdown instead of expecting each new AI chat to rediscover architecture, constraints, and decisions from scratch. I could only verify the title and article snippet, so this summary is based on those visible details rather than the full post text.

Tutorials 📒

iOS Privacy Manifest & Required Reasons APIs: A Compliance Checklist

Mrugesh Tank turns Apple’s privacy manifest rules into a practical checklist, with the clearest value coming from the five required-reason API categories that catch many teams by surprise, especially UserDefaults and system boot time calls. The most useful part is the concrete mapping from API category to allowed reason codes, plus a starter PrivacyInfo.xcprivacyexample you can adapt before App Store submission.

Video 🎥

My Take On The New Apple

Marques Brownlee sees Apple’s leadership change as more than a CEO swap, arguing that John Ternus could push the company back toward more ambitious, product-driven hardware decisions. The sharpest takeaway is the contrast: Apple may be ready to take bigger swings on devices again, but its software side still has a lot of ground to recover.

Watch here.📍

Apple Foundation Models With Mohammad Azam

This Swift Academy episode looks at Apple’s AI direction as an architectural shift, where models become native app capabilities instead of remote chat services. The most useful part is the framing around tools, structured generation, and adapter-based evolution, which makes Foundation Models feel more like controllable system components than generic AI features.

Watch here.📍

Books 📚

Algorithms

Jeff Erickson offers a free electronic version of his self-published algorithms textbook, plus a large set of lecture notes that go beyond the core material into topics like FFTs, linear programming, randomized algorithms, and models of computation. The most useful detail is the scope: this is not a beginner-first data structures book, but a deep reference for readers who already know the basics and want a more theory-heavy path.

Download for FREE.📍

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇

Subscribe now

Those Who Swift - Issue 264

Those Who Swift — Wed, 29 Apr 2026 20:26:55 GMT

Weekly note ✏️

Keeping a balance between resources, budget, and development output is crucial for teams of any size. The principle stays the same whether you are a solo developer or part of a large organization.

A recent example is Anthropic’s decision to make Opus 4.7 the default model for Claude Code starting April 30. Some organizations have already received emails notifying them about this change. The model promises better performance on complex tasks, but it also comes at a higher cost. While the company states that the tokenizer is more efficient and overall token usage should remain stable, real-world testing shows that limits can be reached quickly. At that point, you either slow down and continue manually or pay for additional tokens.

At the same time, social platforms are full of teams openly sharing monthly AI expenses in the range of thousands of dollars. That raises a practical question: at what point does it become more reasonable to invest in people instead of scaling token usage? Some experts already suggest that the so-called AI bubble may begin to stabilize later this year. Initial adoption has happened, workflows are established, and habits are formed. The next step is monetization, which often means higher prices and fewer ways to opt out of AI-driven tools.

For smaller companies, this becomes a real challenge. Being selective with tools, setting clear usage boundaries, and keeping part of the workflow independent from AI can help control costs and reduce risk.

And one more important thing worth mentioning: the App Store Small Business Program. It offers a reduced 15% commission on paid apps and in-app purchases.

Even years after its introduction, many developers are still unaware of it. If you qualify, it’s definitely something to look into.

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Swift Around the Web 🌐

When SwiftUI Modifiers Hold Onto Memory Longer Than Expected

Artem Mirzabekian points out that SwiftUI modifiers can keep reference-type dependencies alive longer than many developers expect, even after the view that used them seems gone. The useful takeaway is architectural: treat modifier-captured objects carefully, especially services or managers, because SwiftUI lifetime and storage behavior may not match the mental model of simple view recreation.

Immediate Tasks In Swift Concurrency Explained

Antoine van der Lee explains that Task.immediate starts running synchronously on the current executor until the first real suspension, which makes it useful for preserving ordering from synchronous actor-isolated code. The most useful warning is the tradeoff: if the first chunk of work is not tiny, immediate tasks can block the caller and even make task-group work accidentally serial.

Q&A: Swift Concurrency - Formatted

Post turns Apple’s live Swift Concurrency session into a cleaner, searchable transcript with timestamps, covering practical questions around MainActor, nonisolated, @concurrent, task cancellation, and actor usage. The most useful part is that it keeps the answers direct and grounded in real migration pain points, especially for teams moving toward newer Swift concurrency defaults.

Coding 👨‍💻

Enums. Swift’s Secret Superpower.

Will Lumley makes the case that Swift enums are far more than named constants, especially once you start using associated values, exhaustive switching, raw values, and enum-driven state. The most useful takeaway is architectural: enums can often replace class hierarchies, boolean-heavy view state, and weakly typed error handling with one safer, compiler-checked model.

Understanding Inout Parameters In Swift - How They Work And When To Use Them

Sagar Unagar reframes inout as an API design tool, not a performance trick, and shows why its real value is making mutation explicit and intentional. The most useful takeaway is the rule of thumb: prefer return values for pure transformations, and use inout only when in-place mutation is the whole point.

Apple 🍏

Monthly Subscriptions With A 12-Month Commitment

Apple is introducing a new App Store subscription option that lets customers pay monthly while committing to a full 12-month term, with payment progress visible in their Apple Account and reminders sent before renewals. The useful part for developers is that this can now be configured in App Store Connect and tested in Xcode, with broad rollout planned alongside the May releases of iOS 26.5 and related platforms.

Design 🎨

Appearance Mode Changer

Stewart Lynch shows a clean SwiftUI pattern for adding System, Light, and Dark mode selection with a small enum, @AppStorage, and preferredColorScheme applied at the app root. The most useful reminder is architectural: keep appearance as an app-level setting so navigation and sheets inherit it automatically without extra view-level logic.

Other cool stuff 🧰

Paywall Design Tips That Boost App Sales - Part 2

Daniils, the founder of AppLayouts, an extensive SwiftUI components library designed to help you build a perfect user interface for your iOS and macOS app in no time, is back with part two. He is sharing tips on broader topics related to paywalls and app monetization in general, based on what he has learned while testing different solutions in his own apps.

I Couldn’t Find The Perfect Browser, So I Built One With AI In Two Weeks

Omar Elsayed shares a very hands-on story of building a native WebKit browser with AI, while staying clear that AI worked best as a strong starting point, not as a replacement for product taste or engineering judgment. The most useful part is the prompt and architecture breakdown, showing how detailed guidance, clear constraints, and human refinement turned a rough idea into a real macOS app.

How To Implement Pagination With SwiftUI’s List View

Natascha Fadeeva shows a simple infinite scrolling pattern for List: add a loading row at the bottom and trigger the next page when that row appears. The most useful detail is the guardrail in loadMoreItems(), since repeated onAppear calls must not start overlapping pagination requests.

AI 🤖

Introducing GPT-5.5

OpenAI says GPT-5.5 is its strongest model yet for real work, with gains in agentic coding, computer use, knowledge work, and early scientific research while matching GPT-5.4 latency and using fewer tokens on some tasks. The most useful practical detail is availability: it started rolling out in ChatGPT and Codex on April 23, 2026, and OpenAI updated the post on April 24 to say GPT-5.5 and GPT-5.5 Pro are now available in the API too.

Customizing Claude Code Memory

Samwize explains where Claude Code stores auto memory, how it is scoped per repo or folder, and which settings can safely override the default location. The most useful tip is that related repos can share memory by pointing .claude/settings.local.json to the same directory, while project-level settings intentionally block redirection for safety.

Claude For Creative Work

Anthropic is positioning Claude as a creative workflow tool, adding connectors for Blender, Autodesk Fusion, Adobe, Ableton, SketchUp, Splice, and other apps creative teams already use. The most interesting part is the workflow angle: Claude can now help across ideation, scripting, asset pipelines, and repetitive production work instead of staying limited to chat.

Tutorials 📒

Concurrency Step-By-Step: Designing Protocols

Matt Massicotte shows how protocol design gets much trickier once Swift 6 isolation rules, @MainActor defaults, and conformance mismatches enter the picture. The most useful takeaway is that synchronous requirements are rigid, while async requirements, nonisolated, and carefully chosen protocol constraints can make conforming types much easier to design.

iOS 26 SDK Migration Guide: What Every App Needs To Update

Mrugesh Tank walks through the practical migration path for apps targeting the iOS 26 SDK, from Xcode 26 and deprecated APIs to Privacy Manifests, Liquid Glass, and regression testing. The most useful part is the checklist mindset: treat build warnings as migration tasks, then test UI, networking, and permission flows early before the App Store deadline hits.

Video 🎥

Microsoft Accidentally Told The Truth About AI

Video argues that recent AI product changes are exposing the real economics behind these tools, especially around cost, value, and the gap between hype and sustainable use. Were are we probably heading and by what cost.

Watch here.📍

And one more thing… 👇

VibeUI: 92 Free UI Prompts For Vibe Coders

VibeUI is a curated prompt library with 92 UI prompts across 15 categories, covering things like auth, pricing, hero sections, dashboards, onboarding, and more. The most useful part is the structure-first approach: you can pick a layout pattern, copy the prompt, and use it in tools like Claude, GPT-5, or Gemini to generate cleaner UI variants faster.

GPT Image 2 Prompts

YouMind has built a large prompt library for GPT Image 2, with more than 2,700 free image and video prompts across categories like infographics, app design, social posts, thumbnails, and posters. The most useful part is the structure: many prompts are written as reusable templates with arguments, which makes them easier to adapt for repeated creative work instead of starting from scratch every time.

Those Who Swift - Issue 263

Wed, 22 Apr 2026 20:30:43 GMT

A few weeks ago, I asked, “How can I improve the newsletter?” I got a bunch of emails with ideas. Thank you! 🫡

A few people mentioned that we should add a indicator (what level of development knowledge is required) next to each piece we share, whether it’s for junior, intermediate, or senior developers. So we did that! ✅

A few others mentioned that it would be nice to have a community. So below, you’ll find a poll. Please vote. 👇

P.S. If we talk about a paid community, it would come with many benefits like well-known developer appearances, tips, unheard stories, and more.

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Today we have a new partner: Hostinger! 🚨

It comes with great deals for OpenClaw and VPS hosting.

You can deploy OpenClaw on Hostinger with one-click deployment, pre-integrated AI tokens, and full control over your sensitive data and chat logs. It also offers 24/7 support and dedicated performance.

OpenClaw Hosting Deal!

One of the fastest virtual private servers, now with a 70% discount. Rock-solid performance and ready to deploy!

VPS 70% OFF Deal!

Associatedtype In Swift Explained - A Complete Guide With SwiftUI Examples

Sagar Unagar explains associatedtype through the distinction that generics choose a type from the caller side, while associated types let the conforming type decide it.

SE-0526: WithDeadline

The Swift Evolution review introduces withDeadline, a concurrency API that cancels work when an absolute deadline passes, while still waiting for the operation to finish cooperatively rather than force-stopping it. The most debated part is the API shape itself, with much of the discussion focused on naming, typed error wrapping, and whether the cancellation behavior should be made more explicit in the name.

A Reusable Spotlight Onboarding Component In SwiftUI

Artem Mirzabekian builds a reusable SwiftUI onboarding spotlight that can highlight any view, show contextual guidance, and keep working across scroll views, navigation, sheets, and safe areas. The most useful part is the implementation approach: anchors and PreferenceKey make the solution flexible without dropping into UIKit-style overlay hacks.

Building A Draggable Bottom Sheet In SwiftUI

Natascha Fadeeva shows how to build a draggable bottom sheet with SwiftUI’s native sheet and presentationDetents, while still allowing scroll coordination and interaction with content underneath like a map. The most useful detail is that you can combine custom detents, disabled interactive dismissal, and background interaction for a bottom-sheet feel without building a fully custom container.

Tim Cook To Become Apple Executive Chairman, John Ternus To Become Apple CEO

Apple announced that Tim Cook will become executive chairman and John Ternus will become Apple CEO on September 1, 2026, marking the biggest leadership change at the company since Cook took over in 2011. The key detail for developers and the industry is that Ternus comes from hardware engineering, which may keep Apple’s product-first direction firmly in place during the transition.

Dotted Background Effect In Metal

Victor Baro breaks down an interactive dotted background shader step by step, showing how SDF circles, fract(), floor(), and touch-driven uniforms combine into glow, attraction, and repulsion effects. The most useful part is the mental model: dots are not moving objects, just pixel math, so the motion comes from shifting each dot’s logical center before rendering.

FormatStyle Guide

Chris Eidhof introduced an interactive browser-based guide to Swift Foundation’s FormatStyle APIs, with live examples for numbers, dates, measurements, and parsing. The most useful part is the SwiftUI angle, since the guide also shows how these formatters plug into real app code instead of staying as isolated API docs.

Five Things I Learned About Making AI Coding Agents Actually Work

Ivan Magda argues that better results from coding agents usually come from better scaffolding, not from switching models. The most useful takeaways are practical ones: keep instruction files short, structure projects so agents can navigate them, start fresh sessions earlier, and give the agent a way to verify its own work.

Introducing Claude Opus 4.7

Anthropic says Claude Opus 4.7 is now generally available, with stronger performance on difficult software engineering tasks, better vision, and more reliable long-running work than Opus 4.6. The practical detail is availability: it is live across Claude products, the API, Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry, with pricing unchanged from Opus 4.6.

Introducing Claude Design By Anthropic Labs

Anthropic says Claude Design lets teams create prototypes, slides, one-pagers, and other visual work through conversation, with support for inline edits, design systems, and exports to formats like PPTX, PDF, Canva, and HTML. The most interesting part is the workflow bridge: once a design is ready, it can be packaged into a handoff bundle for Claude Code, making the jump from idea to implementation much tighter.

Codex For (Almost) Everything

OpenAI says Codex is moving beyond coding into a wider developer workflow, with computer use, image generation, memory, repeatable automations, and support for tools like GitHub reviews, SSH devboxes, and browser-based iteration. The most useful part is the broader scope: it is starting to feel less like a code assistant and more like a workspace agent that can carry context across the full software development lifecycle.

SwiftUI: Refreshable Task Cancellation

Article explains a subtle SwiftUI trap where .refreshable can cancel its own work if state changes trigger a redraw too early. The most useful part is the two-fix breakdown: publish one final state update when possible, or wrap the refresh logic in a separate task when incremental updates are required.

try! Swift Tokyo 2026 Videos

try! Swift is one of the leading international conferences for iOS developers focused on Swift. It gives developers from around the world a great chance to explore the latest trends in Apple platform development and learn from some of the best voices in the community.

Watch here.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift - Issue 262

Wed, 15 Apr 2026 20:30:21 GMT

Weekly note ✏️

While Anthropic is tightening control over its ecosystem by restricting third-party access tools like OpenClaw from its subscriptions to prevent overuse, another story is unfolding behind the scenes. Their upcoming model, Mythos, expected later this month, has reportedly been paused due to security concerns.

During early testing, the model was able to bypass guardrails and escape its sandbox. Ironically, a system designed for security research and penetration testing did exactly what it was built to do. That result raised serious concerns, even among its creators. The situation escalated enough that Anthropic partnered with a wide group of companies, including potential competitors, under Project Glasswing. The goal is clear: understand how to prevent future models from autonomously exploiting systems and instead keep them focused on safe, controlled tasks.

This highlights an important shift. As models become more capable, the challenge is no longer just performance or quality, but control and containment.

Meanwhile, on the other side of the bridge, the hiring market tells a very different story. AI-generated job descriptions are still filled with outdated requirements. Take-home assignments ask for UIKit and Combine implementations in 2026, often without third-party dependencies or modern layout tools. What exactly is being tested here? The ability to work under stress, or the willingness to ignore years of progress?

Development should not feel like driving on unbalanced wheels. If a company is not explicitly hiring for maintaining legacy systems, it’s worth thinking twice before investing time in such unpaid tasks. Your time is valuable, and the tools you choose should reflect the present, not the past.

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

See How Often the Top Swift Apps are Shipping

Release frequency is one of the strongest signals in the App Store algorithm. App Navigator shows you how your update cadence stacks up against the best apps in your category.

Takes about 10 seconds! 🚀

Compare your app

Swift Around the Web 🌐

Lazy Properties In Swift - Why They Don’t Always Work In SwiftUI

Sagar Unagar explains that lazy is useful for deferred and cached initialization, but it becomes misleading inside SwiftUI views because view structs are recreated often and body is non-mutating. The most useful takeaway is practical: keep lazyfor class-based objects with stable identity, and use @State or @StateObject when SwiftUI lifecycle control matters.

Read more.📍

Interface Segregation Principle In IOS: How To Prevent A Protocol From Becoming A Prison

The post shows how a clean UserService can slowly turn into a fat protocol with hidden coupling, brittle mocks, and cross-team bugs, then makes the practical case for splitting it into focused providers with narrower contracts

Read more.📍

Coding 👨‍💻

How To Test In-App Purchases Locally Using StoreKit

Natascha Fadeeva shows how StoreKit’s local configuration files make purchase flows much faster to test, including subscriptions, failures, renewals, and refunds without relying on App Store Connect. The most useful part is the practical setup: attach a local or synced .storekit file to the scheme, then use Xcode’s transaction manager to reproduce edge cases quickly and predictably.

Read more.📍

SwiftUI WithAnimation Completion On iOS 13–16

Artem Mirzabekian explains that withAnimation on iOS 13–16 has no built-in completion callback, so you need your own workaround if later logic depends on animation finish. The useful part is the practical direction: observe an animatable value instead of the animation itself, since native completion support only arrived in newer SwiftUI APIs.

Read more.📍

Apple 🍏

Hello Developer: April 2026

Apple’s April 2026 Hello Developer roundup points to a useful pre-WWDC mix: a live Swift concurrency session with Apple engineers on April 23, fresh sample code for a SwiftUI travel wishlist app, and a reminder to brush up on core topics before WWDC26. It also highlights new social channels on bilibili and LinkedIn, plus the latest Analytics expansion in App Store Connect.

Read more.📍

Other cool stuff 🧰

Paywall Design Tips That Boost App Sales

Daniils, the founder of AppLayouts is sharing tips on how to design paywalls to boost app sales. Effective paywalls sell outcomes, not just features: use value-based messaging, stronger CTA copy, and richer, more engaging layouts that build trust and keep users exploring instead of dismissing the screen.

This is part 1. Part 2 is coming on April 29th. Subscribe to Indie App Devs!

Read more.📍

Design 🎨

Checking Accessibility With SwiftUI Previews

Rob Whitaker shows how SwiftUI previews can do more than visual checks by helping you catch accessibility issues around Dynamic Type, bold text, dark mode, locale, and right-to-left layout before running on a device. The most useful part is the mix of official preview traits and carefully scoped private environment keys for testing things like increased contrast, reduce motion, and button shapes.

Read more.📍

AI 🤖

Kids And Vibe Coding: The Joy Of Building

Jordan Morgan shares a surprisingly warm take on kids building apps with AI, where messy prompts and rough UX still turn into real learning and excitement. The most useful insight is that AI changes the tool, not the craft: product sense, design judgment, and knowing how software actually works still matter.

Read more.📍

AI Won’t Replace Developers — But Developers Who Use AI Will Replace You

Batikan Sosun describes the moment AI stopped feeling like hype and started feeling like leverage: a feature that usually took 6–8 hours was finished in about 2, with results that still held up. The most useful takeaway is not fear but adaptation, because the real shift is toward developers who can use AI for architecture, boilerplate, debugging, and refactoring without giving up judgment.

Read more.📍

Video 🎥

Swish: Clojure-Like Lisp For Swift Video Series

Rod Schmidt shares his video series on building Swish, a Clojure-like Lisp for Swift with Claude Code. The most interesting part is the end goal: an embedded interpreter or Swift-linked compiler that could power app business logic, scripting, or even cross-platform experiments with Swift on Android.

Watch here.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift - Issue 261

Wed, 08 Apr 2026 20:29:38 GMT

Weekly note ✏️

Instead of a regular weekly note, this week I have ✌️ questions for you.

First, the best idea, or a few of the best ideas, will be rewarded with $50 (Amazon, PayPal, or something similar). I want to pick your brain. 🧠

How can we improve this newsletter?
What new section can we add?
What should be different or improved?
What you would do differently?

Any ideas are welcome! 1-3 best ideas will be rewarded. 💸

Just reply to this email with your idea or ideas! 🫡

Second, from time to time I share discounts on books. I’m wondering if you’re interested in that kind of thing. Today’s deal can be find below in “Friends” section.

Please vote in the poll below. 👇

THANK YOU!

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Swift Around the Web 🌐

Mutex In Swift - Protecting Shared Mutable State With Locks

Sagar Unagar explains where Mutex fits in modern Swift: not as an actor replacement, but as a lower-level tool for tiny synchronous critical sections where await would add overhead. The most useful part is the practical guidance around withLock, nonisolated, and avoiding deadlocks by keeping locked work small and never nesting the same mutex.

Read more.📍

MLX Swift: Enabling On-Device Large Language Models On Apple Silicon

Walid Sassi breaks down MLX Swift as a native way to run quantized open-weight LLMs on Apple Silicon, with a clear comparison against Apple’s Foundation Models approach. The most useful part is the practical stack view: MLX Core, MLX-LM, Hugging Face distribution, Metal toolchain setup, and a working SwiftUI-based chat session flow all in one guide.

Read more.📍

Coding 👨‍💻

SwiftUI Custom Popover

Artem Mirzabekian shows how to build a reusable custom popover with matchedGeometryEffect when SwiftUI’s standard .popover is too limiting, like when you need an overlay without an arrow. The most useful part is the tiny API design: a shared namespace, a selection binding, and paired matchedPopover / matchedPopoverSource modifiers that make the behavior reusable across views.

Read more.📍

Building List Replacement In SwiftUI

Majid Jabrayilov shows that List is often the wrong fit for mixed, card-style interfaces, where ScrollView plus lazy stacks now offer more control without much performance loss. The most useful part is the set of reusable primitives built with Container View APIs, letting you recreate sectioned, divider-rich, navigation-friendly layouts with a more custom feel.

Read more.📍

Apple 🍏

App Store Expands Support To 11 New Languages

Apple says App Store Connect now supports localized metadata for 11 new languages, bringing the total to 50 and adding Bangla, Gujarati, Kannada, Malayalam, Marathi, Odia, Punjabi, Slovenian, Tamil, Telugu, and Urdu. The most useful part is the practical reach: developers can now localize app names, descriptions, screenshots, and marketing badges for these languages, with Apple specifically highlighting India as a growth opportunity.

Read more.📍

Updated Apple Developer Program License Agreement Now Available

Apple Developer Program License Agreement was revised on March 30, 2026 to support new features, policy updates, and clarifications. The most notable changes affect requirements for the Foveated Streaming, Family Controls, Accessory Notifications, and Accessory Live Activities frameworks, so teams using those APIs should review the new terms carefully.

Read more.📍

Get Ready With The Latest Beta Releases

New Beta versions of iOS 26.5, iPadOS 26.5, macOS 26.5, tvOS 26.5, visionOS 26.5, and watchOS 26.5 are now available, along with Xcode 26.5 beta for testing against the latest SDK changes. The practical reminder is to start validation early, confirm app behavior on every relevant platform, and send feedback while the beta cycle is still open.

Read more.📍

Design 🎨

No, SwiftUI Is Not “Accessible By Default”

Rob Whitaker pushes back on one of the most repeated SwiftUI myths and shows where accessibility still breaks without deliberate work, especially around image labels, state changes, semantic controls, and grouped content. The most useful reminder is that SwiftUI gives a better baseline, not a finished result, so real accessibility still depends on intention, correct semantics, and VoiceOver testing.

Read more.📍

Other cool stuff 🧰

Beta Preview: DebugSnapshots

Brandon Williams and Stephen Celis from Point-Free introduce DebugSnapshots, a new Point-Free library for testing reference-type models by generating snapshotable views of their underlying data with the @DebugSnapshot macro. The most useful part is the exhaustive expect flow, which fails with a clear diff when you miss a state change and can even track computed or nested reference-type properties.

Read more.📍

Swift: Dynamic Safari Content Blocker

Itsuki shows how little code a Safari content blocker actually needs, with most of the work living in JSON rules and a small extension target. The most useful part is the dynamic setup: store rules in an App Group, feed them through ContentBlockerRequestHandler, and call reloadContentBlocker whenever the rule set changes.

Read more.📍

AI 🤖

Meet The New Cursor

Michael Truell and Sualeh Asif introduce Cursor 3 as a new agent-first workspace with multi-repo support, parallel local and cloud agents, and quicker handoff between environments. The most useful upgrade is the path from diffs to staged commits and pull requests, plus built-in browser and marketplace support that keeps more of the workflow inside one place.

Read more.📍

Tutorials 📒

Spec-Driven Development With OpenSec

Anton Gubarenko explains why spec-driven development helps AI coding feel more predictable by turning loose prompts into structured artifacts like proposal, specs, design, and tasks. One especially useful part is the OpenSpec walkthrough with delta specs, which keeps the focus on what changed instead of rewriting the whole product spec.

Read more.📍

Video 🎥

Advanced Techniques for Working with Optionals in Swift

Natalia Panferova focuses on lesser-known ways to work with optionals that can make Swift code both cleaner and safer. It looks like a practical refresher on techniques many developers do not use often enough in day-to-day code.

Watch here.📍

Friends 🤝

Grokking Data Structures makes everyday data structures easier to learn, from arrays and linked lists to trees, graphs, and hash tables. It focuses on practical use cases, tradeoffs, and core implementations, with clear examples and visuals that make it beginner-friendly. Plus, for a limited time, you can grab it at a great discount GDS40!

Purchase here.📍

Yet, another thing…🌈

iTerm2 Color Themes

The iTerm2 Color Schemes project collects more than 325 themes for iTerm and related terminals, with easy import support and screenshot previews for each preset. A useful detail is that it goes beyond iTerm2, with ports for Terminal, Kitty, Windows Terminal, PuTTY, Konsole, and other environments, making it a handy place to test or standardize terminal looks across tools.

Read more.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift - Issue 260

Wed, 01 Apr 2026 20:30:49 GMT

Weekly note ✏️

Apple quietly released a significant update to App Store analytics this week, and it deserves attention. The platform now offers deeper insights into user acquisition, engagement, and monetization. Developers can better understand how users discover their apps, what drives downloads, and how different channels contribute to growth.

This update brings features that were previously available mostly through paid analytics tools. For many teams, especially indie developers, this is a major step forward. What used to be a relatively basic stats platform is evolving into a much more advanced analytics environment. It allows developers to make more informed decisions about marketing, product improvements, and revenue strategies without relying heavily on third-party services.

Apple is also encouraging developers to take advantage of these insights to improve conversion rates, refine product pages, and better align their apps with user expectations. Combined with other App Store tools, this creates a more complete ecosystem for growth and optimization.

At the same time, congratulations are in order for the Swift Student Challenge winners. The distinguished winners this year showcased impressive creativity and technical skill, building projects that reflect both innovation and strong understanding of Apple technologies. It’s always inspiring to see how the next generation approaches problem-solving and design.

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Forget about Ruby and Fastlane installation issues!

Discover Codemagic CLI tools — the free, open-source Fastlane alternative for automating iOS builds, code signing and publishing.

open GitHub

Swift Around the Web 🌐

What’s New In Swift: March 2026 Edition

Owen Voorhees and Dave Lester round up a strong month for Swift, led by Swift 6.3 and steady progress toward making Swift Build the future default in Swift Package Manager. The most useful part is the compact mix of signals in one place: release notes, community highlights, concurrency and systems videos, and fresh Swift Evolution proposals worth tracking.

Read more.📍

Thread Vs Queue Vs Actor Executor In Swift: Interview Essentials

Artem Mirzabekian clearly separates three terms that are often mixed together in concurrency discussions: threads execute code, queues schedule work, and actor executors preserve isolation. It is also a nice start to his new interview preparation series, with practical explanations around await, MainActor, reentrancy, and why actors should not be treated as just serial queues.

Read more.📍

Coding 👨‍💻

SwiftUI Coordinator Pattern: Navigation Without NavigationLink

Wesley Matlock shows how a coordinator can centralize pushes, sheets, tab switches, and deep links so SwiftUI views only declare destinations instead of owning navigation logic. The most useful idea is the split between lightweight external deep links and richer in-app routes, which keeps navigation easier to test, refactor, and scale.

Read more.📍

SwiftUI: Charts Axis Scale

Article explains chartXScale(range:type:) through the distinction that matters most in Swift Charts: domain controls which values are visible, while range controls where they are drawn inside the plot area. The most useful part is the practical guidance around .plotDimension(padding:), asymmetric start/end padding, and explicit type selection when you want chart spacing and axis behavior to match the intended layout more precisely.

Read more.📍

SwiftUI View Lifecycle: When onAppear Actually Fires

Karin Prater explains the mental model that clears up most onAppear confusion: it tracks visibility, not view creation, so it can fire many times while @State still survives. The most useful part is the behavior breakdown across TabView, NavigationStack, and lazy containers, especially the reminder that the same code can behave differently between iOS 17 and iOS 18+.

Read more.📍

Apple 🍏

New In-App Purchase And Subscription Data Now Available In Analytics

Apple says App Store Connect Analytics just received its biggest update yet, adding more than 100 new metrics, monetization and subscription data, cohort analysis, and new peer group benchmarks. The most useful part for teams is that subscription reports can now be exported through the Analytics Reports API, making it easier to plug App Store data into internal dashboards and offline analysis.

Read more.📍

App Store Adds Regulated Medical Device Status For Health Apps

Apple Developer Relations says apps distributed in the EEA, UK, or U.S. that fall under Health & Fitness or Medical categories, or reference medical or treatment information, may now need a regulated medical device status in App Store Connect. This status is already required for new qualifying apps, and existing apps must provide it by early 2027 to keep submitting updates.

Read more.📍

Brazil App Store Age Ratings Update To A6 For Some Apps

Apple says that starting March 30, 2026, some apps on the Brazil storefront will automatically move to the A6 age rating on devices running Apple’s 26-era platforms. The change applies to apps with descriptors like user-generated content, infrequent cartoon or fantasy violence, or infrequent contests, and does not affect ratings in other regions.

Read more.📍

Other cool stuff 🧰

The Indie Path: My 5-Layer Framework

Andrei Ilnitskii talks about the massive surge of new apps in the App Store. As the flood of junk keeps rising, he helps answer the questions many people who are just starting out have:

Apple is cracking down on AI-generated apps?
ASO is dead?
How do I validate an idea?
How much runway do I need to go indie?

Read more.📍

CI/CD Build Speed Benchmark: Codemagic Vs GitHub Actions Vs Bitrise

Masaki Sato compares the same iOS Flutter build across GitHub Actions, Bitrise, and Codemagic, showing how much machine specs change both speed and cost. The clearest takeaway is that GitHub Actions stays attractive for low-volume teams, while Bitrise and Codemagic cut build times by more than half in this benchmark.

Read more.📍

Top 10 Developer Tools Apple Introduced At WWDC25

An almost one-year-old post by Cihat Gündüz, but still a very good refresher if you want one practical list of Apple developer tools worth revisiting after last year’s announcements. From Foundation Models and Xcode AI workflows to AlarmKit, SwiftUI WebView, App Store Connect analytics, and String Catalog improvements.

Read more.📍

AI 🤖

OpenAI: Build For iOS And macOS

OpenAI shows how Codex can help native Apple platform work across SwiftUI, UIKit, AppKit, testing, and migration tasks, with examples like fixing Auto Layout issues, adding features, and reviewing pull requests. The practical value is the workflow angle: Codex is presented less as a code generator and more as a teammate for large codebases, refactors, and platform-specific app maintenance.

Read more.📍

Tutorials 📒

Animatable In SwiftUI Explained - Complete Guide With Examples & Deep Dive

Sagar Unagar explains that SwiftUI does not animate views directly, it animates data through animatableData, which is why custom motion depends on exposing values SwiftUI can interpolate. The most useful part is the progression from single-value animation to AnimatablePair and custom VectorArithmetic, showing how to animate richer shapes and data-driven visuals without relying on view-level tricks.

Read more.📍

Video 🎥

Don’t Make This Mistake With A Spacer In SwiftUI

Vincent Pradeilles highlights a common SwiftUI layout mistake: using Spacer in places where it quietly breaks alignment or creates more flexible space than you intended.

Watch here.📍

iOS Agent Skills, App Store Connect CLI, Foundation Models Tokens & More

Sean Allen’s latest Swift News episode pulls together several current Apple dev topics, including iOS agent skills, the App Store Connect CLI, and Foundation Models token work. I could not access the full video page content, so this summary is based only on the verified title and public snippets.

Watch here.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift - Issue 259

Wed, 25 Mar 2026 20:47:23 GMT

Weekly note ✏️

AI apps are getting more autonomous, and Anthropic’s Claude is a great example of that shift. It’s steadily gaining remote and coordinated capabilities, including features like Remote Control and scheduled Cowork sessions. These tools allow you to manage development workflows from your phone, bringing a level of flexibility similar to what OpenClaw introduced earlier, but now with a more integrated approach.

At the same time, its main competitor is moving in a different direction. OpenAI is reportedly shutting down some side products, including the Sora app, to focus on future AGI development and training new models. That shift is not surprising. Model training requires enormous resources, and from a business perspective, maintaining standalone apps that don’t cover their operational costs becomes difficult, especially with an IPO on the horizon. Add ongoing concerns around legal content and deepfakes, and the decision becomes even more understandable.

What we’re seeing is a divergence in strategy. Some companies are expanding real-world usability and control, while others are consolidating efforts around core model development. For developers, this means tools are becoming more like orchestration layers-multiple systems, multiple “strings to pull,” all needing synchronized control. In a way, it starts to resemble a GlobalActor pattern, but at a system level.

This week we’re sharing a practical tip related to this idea. 👇

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Swift Around the Web 🌐

Swift Algorithms - Apple’s Hidden Collection And Sequence APIs You Should Be Using

Sagar Unagar highlights how Apple’s swift-algorithms package can replace a lot of handwritten loops and index-heavy code with clearer, safer collection operations. The most useful part is the practical tour through APIs like combinations, chunking, product, uniqued, and random sampling, with real examples that make the package feel immediately usable.

Read more.📍

Talking Liquid Glass With Apple

Danny Bolella shares notes from Apple’s explanation of Liquid Glass and the tradeoffs behind the design, especially around layering, legibility, and when the effect should step back instead of drawing attention. The most useful part is the product angle: Liquid Glass is not just decoration, it is meant to react to context and hierarchy, which makes adoption more about restraint than adding blur everywhere.

Read more.📍

Swift 6.3 Released

Holly Borla and Joe Heck highlight Swift 6.3 as a broad release with more flexible C interoperability, cross-platform build improvements, embedded Swift updates, and the first official Swift SDK for Android. The most useful developer-facing additions include the new @c attribute, a preview of Swift Build integration in SwiftPM, and Swift Testing improvements like warning issues, cancellation, and image attachments.

Read more.📍

Coding 👨‍💻

iOS App Launch Process: From Tap To First Frame

Artem Mirzabekian breaks app startup into the parts that actually matter for performance: process creation, dyld, pre-main work, UIApplicationMain, scene setup, and the first rendered frame. The most useful reminder is that slow launch often starts before your app delegate runs, especially with too many dynamic dependencies and heavy static initialization.

Read more.📍

SwiftUI Architecture Lessons I Wish I Knew Earlier

Mohammad Azam says most SwiftUI architecture problems come from blurry boundaries, not from SwiftUI itself, and recommends separating container screens from presenter views. His most useful advice is to keep UI state inside views, introduce stores only when needed, and use enums instead of piles of booleans for sheets and flows.

Read more.📍

Apple 🍏

WWDC26: June 8-12, 2026

Apple has announced that WWDC26 will run from June 8 to June 12, 2026, with the full week available online and free for the global developer community. The key reminder is simple: expect new Apple tools, frameworks, and features, plus video sessions, labs, and direct access to Apple engineers and designers.

Read more.📍

Design 🎨

SwiftUI iPad Adaptive Layout: Five Layers For Apps That Don’t Break In Split View

Wesley Matlock argues that horizontalSizeClass alone is too blunt for modern iPad layouts, especially in Split View, and proposes a richer layout environment based on size classes plus real container width. The most useful idea is to branch layout structure once at the root, then let geometry-driven tools like ViewThatFits handle what actually fits in the available space.

Read more.📍

Other cool stuff 🧰

SwiftUI Live Broadcasting With AWS IVS

Itsuki shows how to add live broadcasting to a SwiftUI app with AWS IVS by wrapping the streaming client in an observable manager and bridging camera preview into SwiftUI. The most useful part is the end-to-end flow: permissions, device discovery, session strategy, and UI state all come together in a setup you can adapt for a real creator app.

Read more.📍

I Refactored 3 Apps In A Year. Here’s What I Actually Learned

Jakub Milcarz says the hardest part of returning to an old codebase is not bad code, but lost context and unclear connections. His takeaway after refactoring Coffee Note, Bookie, and Memorize is that clean architecture is less about one perfect pattern and more about making the code feel easy to re-enter and change.

Read more.📍

AI 🤖

Generally Useful Prompts

David Smith shares a practical set of AI prompts he now uses in real app work, from generating SwiftUI previews to creating testing checklists, release notes, and spot-checking new bugs from a git diff. One especially useful pattern is anchoring prompts to the diff since the last release, which keeps the model focused on what actually changed.

Read more.📍

Review Your Own AI-Generated Code

Scott Berrevoets argues that as agents write more production-quality code, the real review bottleneck shifts from implementation to planning, guidance, and specs. His sharpest point is that human review still matters, but it may be more valuable at the plan level while the engineer driving the agent self-reviews the generated code.

Read more.📍

Tutorials 📒

Apple Foundation Models In Practice: Building On-Device AI Features In Swift

Wesley Matlock shows what building real on-device AI features with Apple’s Foundation Models looks like in practice, from availability checks to typed generation with @Generable and @Guide. The most useful takeaway is the production mindset: keep prompts short, validate model availability early, and treat generated data as structured output that still may need verification against real APIs.

Read more.📍

Video 🎥

The Layout Protocol (Part 1)

Chris Eidhof and Florian Kugler revisit an old SwiftUI layout challenge and solve it with the Layout protocol instead of older GeometryReader and preference hacks. The most useful part is the step-by-step custom layout build, including sizeThatFits, placeSubviews, and frame calculations that keep two labels aligned to a bar as space changes.

Watch here.📍

Swift Concurrency Explained With Matt Massicotte

Walid Sassi invited Matt Massicotte to walk through the core ideas behind Swift Concurrency, including actors, isolation, Sendable, and structured concurrency.

Watch here.📍

Yet, another thing…⏩

Web Rewind

Opera’s Web Rewind turns 30 years of internet history into an interactive timeline filled with old web moments, sounds, and artifacts that feel closer to a digital museum than a normal promo site. The most interesting part is the format itself: instead of just listing milestones, it lets you move through eras of the web and revisit how online culture evolved from dial-up days to the AI era.

Nostalgia here.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift - Issue 258

Wed, 18 Mar 2026 21:31:16 GMT

Weekly note ✏️

The IT job market remains shaky. 🫨

Some companies openly state they plan to extract as much value as possible from AI tools before expanding their teams again. Reuters reports that Meta is preparing another round of layoffs as AI-related costs continue to grow. At the same time, the rise of new data centers doesn’t necessarily translate into more jobs, since they require far fewer engineers to operate.

On the other side, some companies are taking a longer view. IBM, for example, is investing in junior roles and redefining what entry-level positions look like. Their approach focuses on a combination of human skills and AI collaboration, rather than replacing one with the other. It’s a promising direction, but it doesn’t immediately solve today’s challenges for developers.

Right now, the hiring process is still difficult. Passing ATS filters, dealing with outdated job descriptions, and going through demanding technical interviews often feel disconnected from real work. It’s a tough environment, and expectations are shifting faster than the processes themselves.

So what can be done? 🤔

Modern problems require modern solutions. Tools like tailored-resume-generator are becoming part of the process, helping candidates better match job requirements and pass initial filters. It’s not ideal, but it reflects the reality of the current market.

For now, adaptability remains the key skill.

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Sponsor 🤝

Cut App Store Fees on Every Subscription You Sell!

web2wave lets subscription mobile apps run web onboarding funnels — users complete a quiz, pay on the web, then download the app with an active subscription. No app store cut on those transactions.

Build web2app funnels with a no-code quiz and paywall editor
Get paid in 1-2 days instead of waiting 30 days for app store payouts
Add A/B tests and cancellation flows without app releases
Restore attribution after ATT with full web-side tracking

Works out of the box with Stripe, Paddle, PayPal, Primer, Unlimit, ChargebackHit, AppsFlyer, Adjust, RevenueCat, Adapty, and more.

Free to use until you launch paid traffic.

Try web2wave free

Swift Around the Web 🌐

Copy-On-Write In Swift: Semantics, Misconceptions, And A Custom Implementation

Artem Mirzabekian explains why copy-on-write is really about preserving value semantics while avoiding unnecessary copies, not about structs being “magically cheap” by default. The most useful part is the practical angle: understanding storage sharing and uniqueness checks makes it easier to reason about Swift collections and build your own efficient COW types.

Read more.📍

Swift Some Vs Any: Understanding Opaque Types And Existential Types

Sagar Unagar gives a clear mental model for one of Swift’s most confusing topics: some hides one concrete type, while any can hold many conforming types at runtime. The most useful part is the trade-off breakdown, showing why somekeeps compile-time optimizations while any adds flexibility with a small runtime cost.

Read more.📍

Coding 👨‍💻

Apple Doesn’t Show SwiftData iCloud Sync Status — So Let’s Build One

Muhammad Azam shows that SwiftData has no public API for sync progress, but Core Data’s CloudKit notifications can still power a useful status monitor. The most practical part is the small state-driven setup that surfaces uploading, downloading, success, and failure states in SwiftUI.

Read more.📍

Working With String Catalogs In iOS Projects

Natascha Fadeeva shows how String Catalogs reduce manual localization work by letting Xcode detect keys automatically and track states like new, stale, and needs review. One of the most useful tips is to rename keys inside the catalog editor, because Xcode can update code references while keeping existing translations intact.

Read more.📍

Apple 🍏

Apple Lowers App Store Commission Rates In China

Apple Developer Relations says App Store rates in mainland China will drop on March 15, 2026, with standard paid app and in-app purchase transactions moving from 30% to 25%, and qualifying reduced-rate transactions dropping from 15% to 12%. Developers do not need to accept the new terms to receive the lower rates, but they must agree by April 15, 2026 to keep full access to Apple developer resources.

Read more.📍

Apple Developer Is Now On Bilibili And LinkedIn

Apple says developers can now follow its official Apple Developer presence on bilibili and LinkedIn for news, announcements, videos, and event updates. The post also points to WWDC and Meet with Apple activities as part of that broader community feed.

Read more.📍

Other cool stuff 🧰

Over-Extended Types On The Overuse Of Swift Extensions

Pavlo Shkrabliuk argues that many Swift extensions quietly bloat APIs, blur module boundaries, and make refactoring harder than it first appears. His strongest point is simple: if a method would look wrong inside the original type, it probably does not belong in an extension either.

Read more.📍

How To Fix Xcode Source Editor Extensions That Don’t Appear In The Editor Menu

Adin Ćebić found that some Xcode source editor extensions fail to appear because XcodeKit.framework is not embedded in the extension target. His fix is simple: change the framework setting to Embed Without Signing, and use Xcode’s unified logs to spot the Xcode Extension does not incorporate XcodeKit clue.

Read more.📍

AI 🤖

Introducing GPT-5.4 Mini And Nano

OpenAI says GPT-5.4 mini and nano bring faster, cheaper model options for coding, tool use, and subagent workflows, with mini running more than 2x faster than GPT-5 mini. The key practical detail is availability: mini is in the API, Codex, and ChatGPT, while nano is API-only and aimed at low-cost tasks like classification, extraction, ranking, and lightweight coding work.

Read more.📍

Tutorials 📒

Expanding Animations In SwiftUI Lists

Pavel Zak shows why a normal expand/collapse view feels broken inside List, even when the same code animates fine in VStack or LazyVStack. His most useful fix is an Animatable container that measures header and content height, then drives the row size with a smooth 0-to-1 expansion value.

Read more.📍

Video 🎥

SwiftUI Under The Hood: What’s Really Happening When You Update View

Karin Prater looks past SwiftUI’s “magic” and focuses on what happens after state changes like @State updates trigger UI refreshes. I could only verify the video from search previews, not the full transcript, so this summary is based on the available title and snippet.

Watch here.📍

Build A Searchable, Sortable SwiftUI List With An Index Scrubber

Stewart Lynch shows how to make large SwiftUI lists easier to navigate by combining search, sorting, and an index scrubber. I could not access the full video page content, so this summary is based on the verified title and search snippet only.

Watch here.📍

SGConf iOS Videos Are Now Available

iOS Conf SG has published conference videos on its YouTube channel, making recent Apple development talks available to watch on demand. It is a useful catch-up source if you missed the January 21–23, 2026 event in Singapore or want to revisit sessions from speakers across Swift, SwiftUI, AI, design, and product work.

Watch here.📍

Yet, another thing…🎙️

Fix iTerm2 Microphone Permission For Claude Code Voice Mode

Gio shares a quick workaround for macOS when iTerm2 does not appear in Microphone privacy settings. He resets the permission with tccutil and then triggers the prompt with a small Swift command that requests audio access.

Read more.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift - Issue 257

Those Who Swift — Wed, 11 Mar 2026 21:27:50 GMT

Weekly note ✏️

Today we published the 18th issue of Indie App Devs.

Indie iOS developer Danijela Vrzan shares her tips on how to decide which features are worth adding to your app and which ones to leave out.

It’s a great issue, and you can read it here.📍

But that’s not the main story. I connected with her on LinkedIn, and this is what our chat looked like:

I’ve never properly introduced myself, so maybe now is a good time!

Yep, it’s me! 👋

My name is Justas, I’m from Lithuania 🇱🇹
You can find me on LinkedIn & X.
I help companies with SEO/LLMs.
I’m building my new micro-SaaS ➡️ Carousel Maker
I have a 2-year-old boss at home who controls everything. 👶
I like cars and movies. 🏎️

I run a few newsletters:

iOS Dev Tools newsletter with 7,100 subscribers;
Those Who Swift newsletter with 15,000 subscribers;
Indie App devs newsletter with 1,750 subscribers;
Insanely Cool Tools newsletter with 20,000 subscribers.

I make money with all of them, and together they generate around €50,000 in profit per year.

I share more about this in this article - How to Make Money With Newsletter?

So, it’s nice to meet you, and thank you for your support and for reading the newsletters! 👋

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Speed Hacks for iOS Builds

Get this FREE guide to cut CI time and boost reliability.

Learn caching strategies, parallel build tips, and modular architecture tactics to speed up iteration and keep iOS builds running smoothly.

Free guide

Swift Around the Web 🌐

Why I'm Still Thinking About Core Data In 2026

Fatbobman examines why developers stick with Core Data, citing mature capabilities, existing projects, and its object graph design. He notes growing mismatches with modern Swift in expressiveness, concurrency, and type safety, and argues experience-based workarounds are unsustainable.

Read more.📍

Swift At Scale: Building The TelemetryDeck Analytics Service

Daniel Jilg explains how his company built a privacy-first analytics platform handling 16 million monthly users entirely on Swift with Vapor. Swift's compiled nature, Codable protocol, and Xcode development delivered unexpected advantages: catching errors at compile time, preventing security vulnerabilities through type safety, and enabling rapid iteration without containers.

Read more.📍

Coding 👨‍💻

Get Rid Of Your SwiftGen Dependency

Asser Osama explains that Xcode's built-in symbol generation for String Catalogs and asset catalogs now eliminates the need for SwiftGen in many projects by automatically creating type-safe Swift symbols with full compiler validation.

Read more.📍

Exploring Draw Effects And Gradient Rendering In SF Symbols

Gabriel Theodoropoulos explores new SF Symbols 7 features in iOS 26, including drawOn and drawOff effects that animate symbol appearance with three variations: whole symbol, by layer, or individually.

Read more.📍

Other cool stuff 🧰

MVVM and the Cost of Carrying Old Patterns Forward

Mohammad Azam explains that while MVVM was a valuable pattern for WPF and earlier frameworks, applying it rigidly in SwiftUI often leads to unnecessary complexity because Apple designed SwiftUI for state and logic to live close to the view.

Read more.📍

What AI Coding Costs You

Tom Wojcik argues AI coding tools carry hidden costs: cognitive atrophy, loss of deep understanding, and a broken seniority pipeline. Citing a 2026 study where AI-assisted developers scored 17% lower on conceptual tests, he warns that reviewing AI code doesn't build hands-on intuition.

Read more.📍

AI 🤖

How My Software Engineering Workflow Has Changed In The Past Year

Bruno Rocha describes how he does 95% of his work by prompting Claude, letting AI handle complex multi-codebase tasks alone at unprecedented speed. But he worries this efficiency removes the problem-solving joy and deep learning that drew him to engineering, and questions how future AI will train without human-made content.

Read more.📍

Codex Security: Now In Research Preview

OpenAI introduces Codex Security, an AI agent that finds complex vulnerabilities by understanding project context while reducing noise by over 84% and false positives by more than 50%. It helped discover and patch 14 CVEs in open-source projects like OpenSSH and Chromium, and is now available free for the next month to ChatGPT Enterprise, Business, and Edu customers.

Read more.📍

GPT-5.4: Now Available

OpenAI released GPT-5.4, its most capable model yet, integrating advanced coding with native computer use and 1M token context. It achieves 83% in knowledge work tests, surpasses humans in computer use benchmarks, and reduces token consumption by 47% through tool search.

Read more.📍

Tutorials 📒

Creating Overlays On A Map In A SwiftUI App In iOS 26

The article explains how to add polygon, polyline, and circle overlays to maps in SwiftUI by providing coordinates inside the map's content closure, with appearance customization via modifiers like foregroundStyle and stroke.

Read more.📍

Video 🎥

CLAUDE.md for iOS Developers

The video demonstrates how CLAUDE.md (a project root file read by Claude Code, Xcode's Claude Agent, and Codex) transforms AI coding by providing architecture and framework context before every task. It builds a production CLAUDE.md optimized for Swift and SwiftUI projects, showing how to build features using only agent prompts and share one file across multiple projects.

Watch here.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift - Issue 256

Wed, 04 Mar 2026 20:30:21 GMT

Weekly note ✏️

The modern world shows that critical shifts no longer take months or even days. Sometimes they happen in minutes. Thanks to instant communication channels, reactions are immediate and consequences follow just as quickly.

A recent example: Anthropic publicly stated that it will not allow broad usage of its models for military or large-scale surveillance purposes in the U.S. government. Leaving the ethical debate aside, especially considering that OpenAI has taken a different position. This move had an immediate market effect. The Claude app climbed to the top of the AI category on the App Store. Even more interesting, Anthropic released a migration guide explaining how to switch from other AI chat tools to Claude. You can find more details in our AI section.

This raises an important question. We all know how critical backend redundancy is. Should we now think about AI tool redundancy as well? Diversity always intersects with security. Relying on a single provider, whether for infrastructure or AI, increasingly feels risky.

Apple is making its own moves in the backup space. Time Machine will soon drop support for Time Capsules formatted with AFP (Apple Filing Protocol). Official support ends with macOS 27, expected in Fall 2026. AFP is being phased out in favor of SMBv2 and SMBv3 for network file sharing. The hardware itself was discontinued in 2018, and most units are already past their expected lifespan. While a Time Capsule can still function as a Wi-Fi router, it will no longer serve as a reliable backup target for newer macOS versions.

If you’re affected, alternatives include a fast external USB drive connected directly to your Mac, a NAS device such as Synology or QNAP that supports Time Machine over SMB, or a modern router with USB/NAS functionality. Cloud backup services like Backblaze or iCloud can also help, though they don’t replace the full-system snapshot model of Time Machine.

On iOS, we’ve long had Core Data as a built-in persistence solution, and now SwiftData continues to evolve that experience. As part of our collaboration, we’re sharing a SwiftData migration tip from Vlad Tretiak in this issue.

Stay safe, and more importantly, keep your data safe.

Connect with the "Those Who Swift" team - Justas Markus & Anton Gubarenko 👋

Sponsor 🤝

Forget about Ruby and Fastlane installation issues!

Discover Codemagic CLI tools — the free, open-source Fastlane alternative for automating iOS builds, code signing and publishing.

open GitHub

Swift Around the Web 🌐

Modularizing Swift Apps with Swift Package Manager

Kyle Browning explains how to split a large iOS app into independent modules using Swift Package Manager. By separating features, shared utilities, and dependencies into packages, teams gain faster builds, clearer boundaries, and safer parallel development.

Read more.📍

iOS Backend Security Series: Request Signing & Quantum-Safe TLS

This post explores strengthening iOS-to-backend security with request signing and quantum-resistant TLS. It explains how signed requests verify authenticity and integrity, and why preparing for post-quantum cryptography helps protect APIs against future attacks.

Read more.📍

Announcing Swift 6.2.4

The Swift Org has released Swift 6.2.4, a patch update focused on quality and stability improvements across the language, standard library, and tooling, aimed at smoothing the developer experience.

Read more.📍

Coding 👨‍💻

Geometry in SwiftUI Explained

Sagar Unagar breaks down how layout geometry works in SwiftUI, covering tools like GeometryReader, coordinate spaces, and size measurement. The article shows how to position views dynamically and build responsive layouts that adapt to screen size and container context.

Read more.📍

NSCache in Swift

Artem Mirzabekian shares how to use NSCache effectively in Swift to store temporary objects like images or data, avoid memory bloat, and improve app performance with simple caching patterns.

Read more.📍

Design 🎨

All In on Interface Builder: 10 Years Later

Scott Berrevoets reflects on a decade of using Interface Builder at scale, sharing lessons about maintainability, collaboration, and when visual tooling truly helps versus when it hinders productivity in Swift and UIKit projects.

Read more.📍

Other cool stuff 🧰

Notepad.exe - A Notepad for Developers

My friend Marcin Krzyzanowski, who many of you probably know, developed Notepad.exe. It’s a lightweight coding scratchpad for macOS, built for experiments, snippets, and rapid prototyping.

Open it, write your code, and run it - no project setup required.

Read more.📍

The Hidden Cost of Communication

In his article, Joe Fabisevich explains that large tech companies aren't simply overstaffed but are crippled by exponential communication costs that make alignment nearly impossible. He argues this sectoral shift toward smaller, more focused companies is accelerating with AI, leaving laid-off workers in a contracting job market.

Read more.📍

Automating Mac App Screenshots

Amy Worrall shows how to automate App Store screenshot creation for macOS apps using scripts and UI automation, reducing repetitive manual work. The approach enables consistent, reproducible marketing assets across updates while saving significant release time.

Read more.📍

AI 🤖

Developers Are Safe… Thanks to Corporate Red Tape

Mohammad Azam argues that despite rapid advances in AI coding tools, software developers aren’t being replaced: only their workflows are changing. The focus is shifting from writing every line of code to problem-solving, architecture, and validation, making human judgment and domain knowledge more valuable than ever.

Read more.📍

Importing Memory into Claude

Claude’s memory import feature lets you upload documents and notes so the assistant can remember key context across conversations. It helps personalize responses and maintain continuity for ongoing projects, research, or workflows.

Read more.📍

Using Voice Mode in Claude

Claude’s Voice Mode lets you have fully spoken conversations with the assistant instead of typing. You can talk naturally and hear Claude’s responses, switch between text and voice in the same chat, and choose between hands-free listening or push-to-talk depending on your environment.

Read more.📍

GPT-5.3 Instant

OpenAI has introduced GPT-5.3 Instant, an update to ChatGPT’s most widely used model designed to make everyday conversations smoother and more helpful. It improves response accuracy, provides richer web-context answers, reduces unnecessary refusals or disclaimers, and aims to keep interactions flowing naturally while cutting hallucinations and improving reliability.

Read more.📍

Tutorials 📒

Juice It Up With UIKit Dynamics

This tutorial from Whacky Labs shows how to add physics-based motion to your UIKit interfaces using UIKit Dynamics, making UI elements feel alive with gravity, collisions, springs, and other real-world behaviors for more engaging interactions.

Read more.📍

Video 🎥

Staff Engineering in Mobile Teams: Myth vs Reality

This Swift Academy Podcast episode explores the real role of a Staff iOS Engineer and how it differs from a Tech Lead or “Senior++”. With guest Firas Safa (GetYourGuide, former Yassir), the discussion covers expectations, leadership responsibilities, and the broader architectural and cross-team impact of the Staff position in mobile teams.

Watch here.📍

Building a Reusable Network Manager in Swift

This first video in a new series walks through creating a reusable NetworkManager for Swift and SwiftUI projects using async/await and URLSession. It focuses on designing a flexible, generic networking layer with proper HTTP validation, improved error handling, and configurable decoding strategies - so you can cleanly fetch and decode models without hard-coding assumptions.

Watch here.📍

Thanks for reading Those Who Swift! Subscribe for free to receive new posts.

Subscribe now

Those Who Swift

Those Who Swift - Issue 275

Weekly note ✏️

Own Your web2app Funnel and Get Paid in Days

Post-WWDC26: The 3 On-Device AI Patterns That Will Actually Ship This Year

Apple 🍏

Read more.📍Level: Advanced

Read more.📍Level: Intermediate

Read more.📍Level: Intermediate

Tutorials 📒

Read more.📍Level: Beginner

Read more.📍Level: Intermediate

Coding 👨‍💻

Read more.📍Level: Intermediate

Read more.📍Level: Intermediate

Design 🎨

Read more.📍Level: Beginner

Other cool stuff 🧰

Read more.📍Level: Intermediate

Video 🎥

Watch here.📍Level: Intermediate

Those Who Swift - Issue 274

Weekly note ✏️

Swift Around the Web 🌐

Read more.📍Level: Intermediate

Read more.📍Level: Intermediate

Coding 👨‍💻

Read more.📍Level: Intermediate

Read more.📍Level: Intermediate

Design 🎨

Read more.📍Level: Intermediate

Other cool stuff 🧰

Read more.📍Level: Intermediate

Read more.📍Level: Advanced

AI 🤖

Read more.📍Level: Intermediate

Tutorials 📒

Read more.📍Level: Intermediate

Video 🎥

Watch here.📍Level: Intermediate

Watch here.📍Level: Intermediate

Books 📚

Get here.📍

Those Who Swift - Issue 273

Weekly note ✏️

Swift Around the Web 🌐

Read more.📍Level: Intermediate

Read more.📍Level: Advanced

Coding 👨‍💻

Read more.📍Level: Intermediate

Design 🎨

Read more.📍Level: Intermediate

Other cool stuff 🧰

Read more.📍Level: Advanced

Read more.📍Level: Advanced

AI 🤖

Read more.📍Level: Advanced

Read more.📍Level: Beginner

Read more.📍Level: Intermediate

Tutorials 📒

Read more.📍Level: Intermediate

Video 🎥

Watch here.📍Level: Intermediate

Books 📚

Buy here.📍

Those Who Swift - Issue 272

Weekly note ✏️

Swift Around the Web 🌐

Read more.📍Level: Intermediate

Read more.📍Level: Intermediate

Coding 👨‍💻

Read more.📍Level: Advanced

Read more.📍Level: Intermediate

Apple 🍏

Read more.📍

Read more.📍

Design 🎨

Read more.📍Level: Advanced

Read more.📍Level: Advanced

Other cool stuff 🧰