Weekly note ✏️
Software tends to grow. We add another flag, another layer, another workaround. But sometimes the best improvement is removing something we no longer need.
This week’s reads explore four examples of that idea, from simplifying shared code to improving SwiftUI performance and making tests easier to trust.
Quick question: What’s one thing in your codebase you could delete today without anyone missing it? Hit reply and tell me.


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.

The Best Fix Was a Deletion
with Divya Ravi — Technical Editor
We celebrate what we ship: new features, new APIs, new capabilities. We rarely celebrate the code we remove.
But as an iOS engineer, I’ve learned that more code doesn’t necessarily mean a better solution. Every abstraction, configuration option, and workaround adds something the team has to understand, test, and maintain.
This week, four articles reminded me why subtraction deserves more attention.
Start with shared code. William Boles describes the cohabiting trap: code that looks reusable but serves callers with conflicting needs. Each caller disables what another enables, leaving one abstraction to support several different behaviors. His solution is to return those decisions to the callers that own them. The result is simpler code, fewer unused configurations, and fewer places for bugs to hide.
Then look at performance. The hora Calendar team tested an app with 100,000 events and used Instruments to investigate its main-thread stalls. The surprise? SwiftUI updates, not database reads, accounted for most of the problem. Removing an expensive hover effect helped, alongside moving calendar preparation into background snapshots and improving navigation caching. I also appreciate their honesty: these measurements help diagnose the problem, but they aren’t a controlled benchmark.
Make tests easier to trust. Jaim Zuber takes a sixteen-assertion test and breaks it into eight smaller, clearly named tests. Then comes the important step: deleting the original. The coverage remains the same when the full suite runs together, but failures become much easier to understand. A test suite isn’t better simply because it contains more tests. It should help you find what broke.
Finally, let SwiftUI manage its own lifecycle. Sagar Unagar shows how .task can replace manually creating, storing, and cancelling tasks in onAppear. By tying asynchronous work to the view’s lifecycle, SwiftUI handles cancellation and restarts when relevant values change. That’s less bookkeeping for us and fewer opportunities to get lifecycle management wrong.
What connects these examples isn’t simply deleting code. It’s knowing what you can safely remove.
A profiler identifies where time is actually going. Tests help verify that behavior remains covered. Understanding how callers use an API tells you whether an abstraction is earning its place.
Without that evidence, deleting code is just another risky rewrite. With it, removal can be one of the simplest improvements you make. Less code means less to maintain, less for new engineers to learn, and fewer places for bugs to hide.
Of course, not every piece of complicated code is unnecessary. Sometimes there’s a reason it exists that isn’t immediately obvious. Chesterton’s fence is worth remembering: understand why something is there before removing it.
The goal isn’t to delete aggressively. It’s to make decisions with confidence.
So here’s a small exercise for this week: find one flag, option, abstraction, or test that may no longer be earning its place. Check who depends on it, verify the behavior, and remove it if the evidence supports doing so.
You might have just shipped your simplest improvement of the quarter.
What’s the best thing you’ve ever deleted from a codebase, and how did you know it was safe? Hit reply. I’d love to hear your story.
Related reading on this week's theme 📚
Escaping the Cohabiting Trap
William Boles explains why shared code can become harder to maintain when different callers need conflicting behaviors. Using Swift examples, he shows how returning decisions to individual callers can eliminate unnecessary configurations and simplify the underlying design.
📍Level: Intermediate
SwiftUI Profiling with Instruments: 100,000 Calendar Events
The hora Calendar team investigates performance with 100,000 events and discovers that SwiftUI updates, rather than database reads, account for most main-thread stalls. Removing an expensive hover effect, preparing snapshots in the background, and improving navigation caching help address the problem.
📍Level: Intermediate
Decompose Run-On Tests (In Swift Testing)
Jaim Zuber turns a sixteen-assertion test into eight smaller, descriptive tests, then removes the original. The result is clearer failure messages without losing coverage when the complete suite runs together.
📍Level: Intermediate
SwiftUI .task vs .onAppear — Async Work Done Right
Sagar Unagar explains how .task connects asynchronous work to a view’s lifecycle, including cancellation and restarting when a value changes. The article also covers cancellation-aware code and debouncing.
📍Level: Beginner
This Week in Those Who Swift 🗞️
The latest across Swift, Apple, AI, and the community.
Swift Around the Web 🌐
What's new in Swift: September 2026 Edition
Swift.org’s monthly roundup covers Swift 6.4, Swift Build becoming the SwiftPM default, Subprocess 1.0, the first Vapor 5 beta, Google’s official Swift cloud libraries, and SE-0554 on deployment-target conditional compilation.
A useful catch-up on what’s moving across the Swift ecosystem.
📍Level: Intermediate
Advanced macro technique #2: Type inference
Swift macros only see syntax, not static types, so they stumble when callers lean on type inference. Point-Free shows how to generate a nested protocol and a witness type whose associated types recover the inferred type, so a generated memberwise initializer works without annotations.
📍Level: Advanced
Iterative data loading in Swift
Majid Jabrayilov avoids firing dozens of HealthKit requests at once by wrapping the fetches in a custom AsyncSequence. The view model consumes it with a for-await loop, so the screen updates after each batch instead of waiting on everything.
📍Level: Intermediate
Coding 👨💻
Architect SwiftUI Apps for Swift Concurrency
Karin Prater organizes types around the state they own. UI state belongs on the main actor, shared non-UI state belongs in its own actor, and services remain stateless and Sendable. The result is an architecture where concurrency boundaries are clearer and compiler errors are easier to reason about.
📍Level: Intermediate
Bypassing the App Group Trap
Muhammad Zeeshan explains why files saved to an App Group container may not appear in the Files app as expected. His approach uses a security-scoped bookmark to let an action extension write directly to the app’s Documents folder, with a fallback for apps that haven’t been launched yet.
📍Level: Advanced
Configuring UIKit Navigation Bars from SwiftUI
How do you let SwiftUI screens configure a navigation bar when UIKit still owns the navigation stack? Livsy introduces NavBarBridge, which syncs bar items with SwiftUI state without adding a coordinator or a duplicate SwiftUI header.
📍Level: Intermediate
Apple 🍏
Upcoming expiration of Developer ID Certification Authority (Sub-CA)
Apple’s original Developer ID Sub-CA expires on February 1, 2027. If you distribute .pkg installers signed with an affected certificate, plan to re-sign them using a certificate from the G2 Sub-CA before the deadline. Previously notarized apps with a secure timestamp remain unaffected.
Hello Developer: October 2026
Apple’s October roundup includes iPhone Duo submissions ahead of the October 23 launch, additional Duo group labs on October 13 and 15, an October 29 event on app speed and efficiency, Xcode project format updates, and developer documentation translated into eight languages.
AI & Tooling 🤖
Where did my disk go? Xcode, worktrees and AI agents
Running multiple AI agents in parallel can quietly consume disk space through Git worktrees, build products, test outputs, and simulator copies. Karolina Samorek explains how to track down the real source of the problem, why df can reveal what du misses, and how shared DerivedData and routine cleanup can help.
📍Level: Intermediate
Using Xcode 27's localization skills over MCP
Max Seelemann shows how to export Xcode 27’s localization skills with xcrun agent plugin path and make them available to external agents, such as Claude Code, through MCP. Worth exploring if your localization workflow happens outside Xcode.
📍Level: Intermediate
Comparing On-Device and Private Cloud Compute Summaries
Tiago Henriques uses Apple’s Evaluations framework to compare full-text summaries generated through Private Cloud Compute with shorter on-device summaries. He evaluates length, faithfulness, and whether important conclusions survive compression—a practical reminder to measure AI output rather than rely on intuition.
📍Level: Advanced
Design🎨
Visualising data with a hexagonal heatmap in Swift Charts
Matthaus Woolard builds a hexagonal heatmap in Swift Charts using New Zealand earthquake data. The tutorial covers axial coordinates, grouping data into hexagonal cells, custom symbols, and a symmetric-log colour scale. It’s a useful example of choosing a visualization that communicates density more effectively than a standard grid.
📍Level: Advanced
Tutorials 📒
Testing Async Code in Swift: Stop Using Task.yield() in Your Tests
Nikita Vasilev explains why calling Task.yield() before an assertion can make asynchronous tests unreliable, especially under CI load. An injectable task factory gives tests a way to wait for the work they started. And when an API can be made async, simply awaiting it is often the clearer solution.
📍Level: Intermediate
Community 🤝
Why big companies are bad platform citizens
Why do smaller teams sometimes adopt new OS features faster than large companies? Scott Berrevoets explores the trade-offs: expensive integrations, quarterly planning, limited returns on platform work, and business incentives tied to acquisition, engagement, and revenue.
An interesting perspective for anyone building products inside a large organization—or trying to understand why platform adoption takes time.
📍Level: Beginner
Thanks for reading Those Who Swift!
Subscribe for free to receive new posts. 👇
