Snapp Technology
Hi folks,
It’s a very practical issue this week: less “look at the shiny thing,” more “how do we keep our apps from wobbling when real users, real devices, and real shipping pipelines get involved?” SwiftUI is still growing into the Mac, Observation still has sharp performance edges, and agentic coding is clearly moving past loose prompts into repeatable workflows. I like that mix. It feels like where our codebases actually live: half platform nuance, half tooling discipline, and a bunch of tiny decisions that either save us later or make future-us deeply annoyed.
Enjoy!
Articles
Swift
Task alive duration when device is locked
A crisp reminder that a Swift Task is not a magic background execution coupon. If iOS suspends our process, the worker threads stop, URLSession work can get defuncted, servers may time out, and the app might never be resumed before termination. The practical menu is familiar but worth repeating: prevent suspension where allowed, cancel before backgrounding, tolerate failure, or use background URLSession when that’s the job.
AI/ML
User Diagnostics Reports: Solving app bugs faster with AI Agents
Diagnostics reports are one of those boring-sounding features that become gold the first time a user says “it doesn’t work” and gives you nothing else. The pitch here is simple: collect app version, device context, relevant state, and logs in a structured way so support and AI agents can reason from facts instead of guesswork. I’m very into this direction, because our debugging loop should not start with three emails asking for information the app already knows.
Building and Shipping Mac and iOS Apps Without Ever Opening Xcode
Xcode still needs to be installed, yes, but it does not need to be the room we live in. The workflow here is delightfully blunt: use XcodeGen, xcodebuild, notarytool, stapler, devicectl, and a checked-in release script so an agent can build, sign, notarize, install, and deploy without clicking through Organizer. There’s setup pain once — certificates, keychain credentials, team IDs — but after that, our shipping path becomes a command the agent can actually run and verify.
Spec Kit (Spec-Driven Development) in an iOS Project
Spec-driven development feels like the needed backlash to “prompt, pray, accept diff.” The walkthrough puts GitHub’s Spec Kit into a real SwiftUI + TCA project, then drives a Favorites sort and search feature through constitution, spec, clarify, plan, tasks, analyze, and implementation. The best part is not the tooling glamour; it’s that architecture rules, localization requirements, and test-first reducer logic become artifacts the agent has to keep looking at instead of tribal knowledge buried in our heads.
UI/UX
A WWDC 26 Update on Building a Mac-assed App with SwiftUI
A good follow-up for anyone trying to make SwiftUI feel properly Mac-like instead of “iOS app wearing a menu bar.” The useful bits are small but real: backgroundProminence can stand in for custom selection emphasis in some cases, .onDragSessionUpdated looks like the drag-and-drop hook we’ve been missing, and .reorderable may finally make the common case less annoying. Still, the bigger point lands harder: these gaps are rarely dramatic by themselves, but pile enough of them into our apps and suddenly we’re back to reimplementing platform behavior by hand.
The power of previews in Xcode
Previews keep getting better, and the newer pieces are more than convenience sugar. @Previewable cuts out those throwaway wrapper views we keep making just to hold @State, while PreviewModifier gives us reusable preview environments for things like in-memory SwiftData containers or app stores. Who doesn’t like less preview boilerplate, especially when it also makes our component states easier to actually inspect?
Rotating Liquid Glass in SwiftUI without breaking the shape
Liquid Glass makes a simple rotation suddenly less simple, because the effect is tied to bounds and geometry in a way a plain background is not. The workaround leans on a GeometryEffect plus ignoredByLayout() so the rotation stays visual instead of leaking into layout calculations. I’d be careful with the underscored _RotationEffect, but the lesson is bigger and useful: SwiftUI layout geometry and rendered geometry are not the same thing, and sometimes our UI only behaves once we treat them separately.
Equatable properties in @Observable classes
A neat performance detail hiding inside Observation: whether an assignment invalidates dependent SwiftUI views can depend on Equatable. Custom value types stored in @Observable classes notify on every assignment unless Swift can compare the old and new values, so unchanged data from polling, async streams, or framework callbacks can still cause redraws. Adding Equatable to those small model structs is not glamorous, but it can keep our views quiet when nothing actually changed.