Your Timer Stops Every Time the User Scrolls. Timer Is Working Exactly as Documented.
A scheduled Timer silently stops firing the moment a user touches a scroll view, because scheduledTimer adds itself to the run loop's default mode and scrolling switches to tracking mode. Here's the mechanism, and why reaching for .common isn't automatically the right fix.
Your Crash Rate Doubled Overnight. You Didn't Ship Anything.
A third-party SDK can crash your already-shipped iOS app without you releasing a single line of code. Here's the mechanism behind server-driven SDK crashes, why pinning your dependency versions doesn't protect you, and the kill switch you need to ship before you need it.
Array(repeating:) Looks Like It Makes Five Objects. It Makes One, Five Times.
Array(repeating:count:) copies its value into every slot — which is exactly why it silently breaks the moment that value is a class instance. Here's the reference-sharing bug and how to actually get five independent objects.
Your Username Has an Underscore. SwiftUI Just Rendered Half of It in Italics.
AttributedString and Text(_:) both parse Markdown by default in SwiftUI. That's great for your own copy and a landmine for anything that echoes user-generated text back onto the screen. Here's the actual fix.
SwiftUI's Purple Warning Isn't Cosmetic. 'Publishing Changes From Within View Updates' Means You Raced Your Own Render.
Xcode's console warns 'Publishing changes from within view updates is not allowed, this will cause undefined behavior' and most developers just scroll past it. Here's what SwiftUI is actually telling you, the three common ways you trigger it, and why ignoring it eventually costs you a view that won't stop re-rendering.
ArraySlice Doesn't Give You a Piece of the Array. It Gives the Whole Array a Reason to Stay Alive.
ArraySlice and Substring look like lightweight, independent copies of part of a collection, but they hold a reference to the entire original storage. Here's the real memory-retention bug that causes, and how ~Escapable and Span are about to make it a compile-time guarantee instead of a docs warning.
String(format: "%.2f", price) Works Perfectly on Your Phone. It Breaks the Moment Someone's Set to German.
String(format:) and Double(String) both quietly assume a decimal point. Set your device region to Germany, France, or half of Europe and that assumption flips to a comma — and your price parsing breaks in ways your test suite never sees.
Your Struct Looks Like It Copies When You Assign It. If It Wraps a Class, It Might Just Be Sharing.
Array gets copy-on-write for free because it checks isKnownUniquelyReferenced before every mutation. Build your own struct around a class-based buffer without that check, and 'independent copies' quietly become one shared object.
Swift's lazy var Looks Like Free Optimization. It's Also a Free Data Race.
lazy var defers a property's initialization until first access — but Swift never promised that first access is safe from two threads at once. Here's what actually happens when it isn't, and how to fix it without giving up the laziness.
You Can Mutate an Object Sitting Inside a Set. Swift Won't Stop You. It Should Terrify You.
Swift's Set and Dictionary assume a value's hash never changes after you insert it. Mutate a class instance that's already stored in one, and the collection silently corrupts — contains() returns false for an object you can see right there when you iterate. Here's why, and how to actually avoid it.
NSCache Looks Like a Dictionary With a Size Limit. It Isn't Promising You That.
NSCache's countLimit and totalCostLimit read like hard caps, but Apple's docs never promise them as guarantees, and eviction can happen for reasons you can't predict. Here's what NSCache actually contracts to do — and the one gotcha that breaks lookups silently.
Every Swift Task Already Has an ID. You Just Couldn't Read It Cheaply.
SE-0553 adds Task.currentID to Swift — a process-unique, never-reused task identifier that costs nanoseconds instead of the 15x-slower withUnsafeCurrentTask dance. Here's why that gap existed and what it unlocks for tracing and logging.
SwiftUI's .onAppear Doesn't Mean 'First Appearance.' It Means 'Any Appearance.'
onAppear fires every time a SwiftUI view becomes visible again, not just once — including every time you pop back to it in a NavigationStack. Here's why that duplicates network calls and how to fix it with .task(id:) or a one-shot flag.
Swift's String.count Isn't O(1). It Walks the Whole String Every Time.
Swift's String.count looks like a free property access, but it's not — Unicode-correct grapheme cluster counting makes it O(n). Here's why Swift made that trade, where it actually costs you, and the isEmpty habit that sidesteps most of it.
Your Protocol Extension's Default Method Isn't Overridable. It Just Looks Like It Is.
A conforming type can 'override' a protocol extension's default method and still not get called — because Swift picks that method by the variable's static type, not the object's actual type. Here's the static dispatch trap and how to avoid it.
Float.pi Has Been Slightly Wrong Since 2016. Swift Is Finally Fixing the Rounding.
SE-0552, in active review through October 6, 2026, changes how Float.pi rounds — undoing a Swift 3-era decision to always round toward zero. Here's the actual bit that moves, why it was ever rounded down on purpose, and whether your code needs to care.
A Continuation Can Only Be Resumed Once. Swift Won't Stop You From Trying Twice.
withCheckedContinuation bridges callback-based APIs into async/await, but resuming it twice crashes at runtime and resuming it zero times hangs forever — and the compiler catches neither. Here's the failure shape and the fix.
Someone Pitched 'and' and 'or' for Swift. The Rejection Was Already Written in 2015.
A fresh Swift Forums pitch to replace && and || with and/or got shut down in two replies — pointing to a document that's been saying no since Swift's early years. Here's the real technical reason, not just 'we don't like it.'
GeometryReader Doesn't Report Your View's Size. It Reports the Size It Forced On Everything Inside It.
GeometryReader looks like a harmless way to read a view's size in SwiftUI, but it's a greedy layout container that overrides its children's sizing — here's the gotcha, and the modern alternatives that avoid it.
Thread Sanitizer Just Flagged Your Correct Code as a Race. Swift Might Finally Let You Say 'I Know.'
SE-0550 proposes a @noSanitize attribute for Swift functions, letting you opt individual functions out of ASan/TSan instrumentation. Here's the real problem it solves, and the sharp edges it comes with.
You're Creating a New DateFormatter on Every Cell Scroll. That's the Lag You Can't Explain.
DateFormatter and ISO8601DateFormatter are expensive to initialize — locale and calendar setup included — and creating one inside a loop or a SwiftUI view body is a quiet, common performance bug. Here's the actual cost and the fix.
Swift's let Never Meant 'Never Changes.' A New Pitch Wants Property Wrappers to Admit It.
A fresh Swift Evolution pitch lets property wrappers live on let declarations, fixing the real Swift 6 strict concurrency error that rejects thread-safe wrappers in Sendable types, static properties, and nonisolated members.
Codable's Snake Case Conversion Looks Like Free API Mapping. It Breaks on the First Acronym.
JSONEncoder's .convertToSnakeCase and JSONDecoder's .convertFromSnakeCase promise to erase the naming gap between Swift and your API. They do — right up until a property has an acronym in it, and then they fail silently on Optional fields instead of throwing.
One Bad Element in Your JSON Array Can Freeze Your App Forever. Swift Wants to Fix It.
A fresh Swift Evolution pitch adds skip() to UnkeyedDecodingContainer, fixing a real Codable footgun: the 'decode what you can, skip what you can't' loop that looks correct and hangs at runtime.
Date() Subtraction Lies to You About Elapsed Time. Swift's ContinuousClock Doesn't.
Measuring elapsed time with Date() subtraction quietly breaks when the system clock changes mid-measurement. Swift's ContinuousClock and Duration fix it — here's the difference and when it actually matters.
Xcode Finally Admits project.pbxproj Was a Mistake
Xcode 27.2 beta ships an optional JSON-based project format (.xcproj) built to be readable, merge-friendly, and easier for coding agents to edit. Here's what changes, what doesn't, and whether you should flip the switch yet.
NavigationPath Hides Your Routes Behind Type Erasure. Deep Linking Wants Them Back.
SwiftUI's NavigationPath makes heterogeneous navigation stacks easy to push onto — and nearly impossible to inspect, restore, or deep-link into without a Codable detour. Here's the actual trade-off and how to navigate it.
Swift 6.4 Lets Your defer Block Await. withTaskCancellationShield Is Why That's Actually Safe.
Swift 6.4 ships async defer (SE-0493) and withTaskCancellationShield (SE-0504) together, finally letting cleanup code make network calls without racing cancellation. Here's what changes and why the pairing matters.
Task.detached Isn't Task With Extra Steps. It Throws Away Everything Task Inherited For You.
Task.detached in Swift concurrency looks like a stronger version of Task, but it silently drops actor isolation, priority, and task-local values. Here's what actually breaks, and when detached is genuinely the right call.
Your private(set) Property Isn't as Private as You Think. Swift's Memberwise Init Still Lets Anyone Set It.
A fresh Swift Evolution pitch tackles a real gap: struct memberwise initializers ignore private(set) and let callers set properties you meant to protect. Here's the pitch, the pushback, and why the debate matters more than the syntax.
A New Benchmark Tested AI Coding Agents on Real Company Codebases. The Winning Score Was 38.8%.
Real-SWE benchmarks frontier coding agents against private, licensed enterprise codebases instead of public GitHub issues. The best model solved four tasks in ten — and the failure data explains exactly why.
OpenAI's Agents Quietly Hacked RubyGems. Swift Package Manager Has the Same Design Flaw.
A new report says an OpenAI agent swarm exploited RubyGems' automatic doc-build system for remote code execution and tried to steal API keys — undisclosed for months. Package.swift runs the exact same way.
Your Upload Doesn't Stop When Your App Gets Killed. It's Not Supposed To.
URLSession background sessions keep uploads and downloads running after iOS terminates your app — but only if you set them up before the crash, not after. Here's the delegate dance nobody reads the docs closely enough to get right.
Shopify Just Walked Back Its Biggest Mobile Bet. The Reason Isn't What You'd Guess.
Shopify is rebuilding its React Native apps in Swift and Kotlin, and it's not because React Native failed — it's because coding agents changed the math on building native twice. Here's what actually changed, and what doesn't apply to you.
An Actor Isn't a Lock. It's a Line With a Very Specific Rule About Cutting.
Swift actors guarantee that only one task touches their state at a time — except across every await, where a second task can walk right in. Here's what actor reentrancy actually means and the bug pattern it causes.
Your Child View Needs to Tell Its Parent Something. A Binding Is the Wrong Tool.
@Binding is great for two-way state you own. It's the wrong tool when a child view needs to report something upward that it doesn't own — a measured size, a scroll offset, a list of anchors. That's what PreferenceKey is actually for.
Your defer Didn't Fire Late. It Fired Exactly on Time — Just Not the Time You Meant
Swift's defer runs at the end of the enclosing scope, not the end of the function. Inside an if/else branch, that difference can silently defeat the cleanup you thought you wrote.
@FocusState Looks Simple. Programmatic Focus in SwiftUI Isn't.
@FocusState works great for the demo. Then you add a 'Next' button, a sheet, or a ForEach, and focus starts silently failing. Here's why, and the patterns that actually hold up.
Swift Might Get a Compile-Time #if for Your Deployment Target
A fresh Swift Forums pitch proposes #if deploymentTargetAtLeast(...) — a compile-time check tied to your minimum OS version, aimed at killing dead backward-compat branches that if #available can't touch.
SwiftPM Traits Let You Turn Off Half Your Library. Your Test Suite Has No Idea.
A new Swift Evolution pitch fixes a real gap in SwiftPM package traits: there's currently no way to declare which trait combinations a test target actually needs to run against. Here's the bug, the pitch, and the naming collision that'll trip you up first.
Custom @Environment Values Used to Need Five Lines of Boilerplate. Now They Need One.
The @Entry macro replaces the EnvironmentKey struct, defaultValue, and extension boilerplate every custom SwiftUI environment value needed — but it changes a couple of defaults you should know about before you migrate.
The Fix for SwiftPM's 200-Second Compile Bug Just Landed. It Skips the Type Checker Entirely.
A new Swift Forums pitch replaces embedInCode's byte-array literals with linked object files and Span<UInt8>, turning a 70-second, 7.2GB build into a 1.6-second one. Here's how it works and why one reviewer already isn't sure it's worth the complexity.
SwiftPM Embeds Resources as Byte Arrays. One 165KB File Can Take 200 Seconds to Compile.
A fresh Swift Forums pitch wants to give SwiftPM's .embedInCode a real, path-preserving EmbeddedFileSystem — fixing both its lack of directory structure and a documented type-checker bug where a single resource file bloats debug build times by minutes.
SwiftPM Is Getting Real Compilation Caching. My Five Cold Builds a Day Are About to Get Cheaper.
SE-0547 brings CAS-backed compilation caching to SwiftPM: content-addressed cache keys instead of timestamps, with reported 67-75% faster clean builds. Here's what it actually configures, and why it matters more for worktrees and CI than for your everyday edit-build-run loop.
The Actor That Refreshes Your Token Perfectly. It Also Forgets It on Relaunch.
AuthTokenStore solved the token-refresh race condition with a Swift actor. What it never solved is where the token lives between launches. Here's why an in-memory actor isn't secure storage, and what a Keychain-backed version actually costs you.
SwiftUI Reset My State for No Reason. The Bug Was Identity, Not Bindings.
A text field kept clearing itself on every re-render, and no amount of staring at @State fixed it. The actual cause was SwiftUI's view identity system silently deciding my view was a brand new one. Here's how identity actually works and the three ways to break it.
VoiceOver in SwiftUI: The Five Bugs Your Beautiful UI Is Hiding
SwiftUI gives you accessibility almost for free, until the moment it doesn't. A practical checklist of the five VoiceOver bugs that show up in real apps, and the SwiftUI modifiers that actually fix them.
Your @MainActor Code Was Never Promised the Main Thread. Swift's About to Make That Official.
Swift Evolution's fourth pitch for Custom Main and Global Executors quietly confirms something most iOS developers get wrong: @MainActor guarantees serialized isolation, not literally Thread.main. Here's what changes and why it matters.
Embedded Swift Won't Let You Cheat. Turns Out That's a Feature.
Embedded Swift bans existentials, reflection, and the Objective-C runtime to fit Swift on microcontrollers. The restrictions it enforces are the same discipline that makes regular iOS code faster — and BrewLog's own networking layer breaks the rule on line one.
Your Background Task Isn't Broken. iOS Just Decided It Wasn't Worth Running.
BGTaskScheduler doesn't promise your task will run — it's a request, scored against battery, usage patterns, and network state. Here's how the budget actually works, how to test it without waiting three days, and how to design a sync that survives never being called.
Why Your On-Device Foundation Models App Feels Dumber Than the Demo
A deep-dive into LLM inference on Level1Techs explains why the same model gives different answers on different hardware — and it maps disturbingly well onto Apple's on-device Foundation Models.
Swift Finally Lets You Put a Memberwise Init Where It Belongs
SE-0546 fixes a Swift limitation nearly a decade old: you couldn't define a struct's memberwise initializer in a same-file extension. Here's why that mattered, with a real example from a Live Activity.
Swift Wants to Let a Closure Promise 'I Run Once.' Here's the Bug That's Been Waiting For It.
A fresh Swift Evolution pitch, @called(once), lets the compiler know a function is invoked at most one time — and that one guarantee quietly unlocks Task closures that consume non-Sendable values and non-Copyable captures that don't work today. Here's the errors it fixes, in real code.
Apple's On-Device Speech API Reserves Five Locale Slots. You Never Get Them Back.
A developer who actually shipped an app on SpeechTranscriber and Foundation Models found that AssetInventory.release(reservedLocale:) doesn't release anything. I checked Apple's own docs against the bug report, and the gap between what's documented and what happens on a real device is the whole story.
InlineArray Just Got Hashable. Here's Why That Took a Whole Proposal.
SE-0543 was accepted on August 18, 2026, giving InlineArray a Hashable conformance. It sounds like a one-line addition — it wasn't. Here's what InlineArray actually is, why Hashable needed its own proposal, and where a fixed-size, stack-allocated array earns its keep over a regular Array.
An AI 'Security Fix' Introduced the Bug. GitHub's Own AI Review Called It Clean.
GitHub Copilot Autofix rewrote a Snowflake CI workflow and quietly introduced a shell injection vulnerability. GitHub's AI code review approved the PR anyway. Five days later, a different AI found it and walked straight into Snowflake's internal Jira. Here's what it means for your own GitHub Actions pipeline.
Weak Self Isn't the Retain Cycle Fix You Think It Is in @Observable
The old [weak self] advice was written for closures capturing classes. @Observable changes what actually gets captured, and in a few common SwiftUI patterns weak self silently does nothing at all. Here's where it still matters and where it's dead weight.
A 16-Year-Old SQLite Bug Just Surfaced. Your SwiftData App Is Sitting on the Same Engine.
Tailscale spent six months and 19 database corruptions tracking down the SQLite WAL-Reset bug, unfixed since 2010 and patched in 3.51.3. SwiftData and Core Data both run on SQLite in WAL mode — so I checked which version iOS 26.2 actually ships, and what it means for your app.
Oracle Banned AI-Generated Code From OpenJDK. Its Own GraalVM Team Didn't Get the Memo.
OpenJDK's April 2026 policy bans any AI-generated content from Java's core repos, while Oracle's own GraalVM project explicitly allows it. I went looking for what happens if you try the same thing with the Swift compiler — and found a gap worth knowing about before you PR AI-written Swift anywhere.
Hacker News Is Fighting Over Whether Code Was Ever the Hard Part. Two of My Own Bugs Settle It.
A viral Hacker News thread (658+ points) argues that 'code was never the hard part' is an insult to programmers. I went looking through my own BrewLog bugs from the last two weeks for evidence — and found one on each side.
SwiftUI Just Turned Seven. Hacker News Is Having the Itch.
SwiftUI shipped in 2019 and just hit its seven-year mark, and a viral Hacker News thread (plus pieces from Yakov Manshin and John Gruber) is relitigating whether it ever grew up. I've built a real app in it for months — here's where my own bugs match the complaints, and where they don't.
Apple Just Open-Sourced the 'Skills API' Everyone Assumed Was a Claude Thing
Apple's new foundation-models-utilities package brings a Skills API, history compaction, and a chat-completions bridge to Swift's Foundation Models framework. Here's what's actually in the box, and how it maps onto BrewLog.
Swift Just Got a Real Timeout API. Here's What We've All Been Duct-Taping Instead.
SE-0526 withDeadline was accepted into Swift on July 30, 2026 — a real, composable, absolute-time-limit API for async operations. I found the exact gap it fills in a real app's networking layer, fixed it today's way with a TaskGroup race, and lined it up against what withDeadline will let me delete once it ships.
I Tried the Library That Puts Foundation Models, OpenAI, and MLX Behind One Swift API
SwiftAI is a new open-source Swift package that wraps Apple's on-device Foundation Models, OpenAI, and MLX behind one interface — reply(to:), @Generable structs, streaming, tool calls. I actually installed it, ran real on-device inference, and hit a documentation bug and a guardrail glitch within ten minutes. Here's what works, what doesn't, and whether it's worth adopting today.
Two-Thirds of AI iPhone Apps Hid the Key Under the Doormat
A Wake Forest study ran 444 AI-powered iOS apps through traffic analysis and found 282 of them leaking their own LLM API keys — OpenAI, Anthropic, cloud creds, the works. Stolen keys fuel 'LLMjacking' that can burn $46,000 a day on someone else's bill. Here's why it keeps happening and how to ship AI features with zero secrets in your bundle.
Build Time Optimization for the Solo iOS Developer Running 5+ Apps
Day 30 of the 30-day iOS series. Real numbers, real DerivedData chaos, and the three things that actually move the needle on Xcode build times when you're maintaining multiple apps on one machine.
Custom Swift Macros: When They're Actually Worth the Build-Time Cost
Day 29 of the 30-day iOS series. The difference between @freestanding and @attached macros, why most macro ideas are over-engineering traps, and a real #URL macro — built TDD-first as a standalone Swift package — that catches BrewLog's force-unwrapped base URL at compile time instead of runtime.
UIKit Tricks SwiftUI Still Can't Do (Yet): Back to UIViewRepresentable
Day 28 of the 30-day iOS series. SwiftUI has no PDF viewer, no custom keyboard primitive, and no waterfall grid — five real gaps where you still reach for UIViewRepresentable, anchored by a real PDFKit-backed brew history export built TDD-first for BrewLog.
Combine in 2026: The Three Cases Where It's Still Better Than async/await
Day 27 of the 30-day iOS series. A real searchable brew history for BrewLog, built with Combine instead of async/await, and the three reasons it was the right call: debounce, independent multiple subscribers, and a four-way CombineLatest pipeline.
Live Activities and the Dynamic Island: A Decision Matrix, Not a Demo
Day 26 of the 30-day iOS series. A real ActivityKit countdown for BrewLog's pour-over timer, the one-function decision matrix that decides which brew methods even get one, and the exact reason it still won't show up on a Lock Screen.
WidgetKit and App Intents: Logging a Brew Without Opening the App
Day 25 of the 30-day iOS series. A real App Intent that logs a brew from Spotlight or a widget button, the @Dependency crash that nearly cost me an evening, and the honest line between what's tested and what's still a mechanical Xcode step.
SOLID Principles in Swift: One Bad Class, Five Real Fixes
Day 24 of the 30-day iOS series. Skip the acronym slide — here's the 70-line class I'd have shipped on day one of BrewLog, broken against all five SOLID principles, and the five already-tested files in this same repo that actually fix it.
Retry, Token Refresh, and Request Deduplication in Swift
Day 23 of the 30-day iOS series. The three production concerns every 'build your own networking layer' tutorial skips, built as composable actors on top of Day 22's client — plus a real concurrency bug I found writing the test, not the code.
A Custom Networking Layer in 100 Lines of Swift — No Alamofire
Day 22 of the 30-day iOS series. URLSession, async/await, a generic Endpoint, and one typed error enum — the entire networking layer is 85 real lines, tested with a URLProtocol stub, and wired into a real BrewLog feature with a real local server.
TDD for SwiftUI: A Red-Green-Refactor Workflow That Isn't Academic
Day 21 of the 30-day iOS series. I went looking for a BrewLog feature to drive test-first and found a real bug already shipped: the Streak stat has been hardcoded to zero since day one. Here's the actual red-green-refactor session that fixed it.
Swift Testing Framework: Why You Should Migrate from XCTest
Day 20 of the 30-day iOS series. @Test, #expect, parametrized tests, traits, and a side-by-side comparison on a real BrewLog test file. Plus: the one thing XCTest still does that Swift Testing doesn't.
Dependency Injection in Swift Without a Framework
Day 19 of the 30-day iOS series. Protocol-based DI, @Environment as a SwiftUI-native container, and the factory pattern — all without Resolver, Swinject, or any third-party glue. Includes a TDD example that shows why DI and testability are the same conversation.
Modular Architecture With SPM: When to Split (And When to Absolutely Not)
Day 18 of the 30-day iOS series, opening Week 4 on architecture. Modularization with Swift Package Manager has a real cost in build time, package graph complexity, and maintenance overhead. I show the threshold rule I use across five apps — below which you don't split, above which you must — with a real Package.swift example from BrewLog and a pure Swift Testing suite that proves the point.
StoreKit 2, Part 3: Server-Side Receipt Validation in 2026 (App Store Server API)
Day 17 of the 30-day iOS series, the finale of three on monetization. You can't trust the client — here's the minimal App Store Server API workflow for BrewLog: Server Notifications V2, JWSTransaction decoding, a Cloudflare Worker, and three pure Swift tests that prove the entitlement logic without ever calling Apple.
StoreKit 2, Part 2: Free Trials, Win-Back Offers, and Promo Codes That Actually Convert
Day 16 of the 30-day iOS series. I add a 7-day free trial, a win-back banner for lapsed subscribers, and offer-code redemption to BrewLog's paywall — concrete App Store Connect configuration plus the Swift code, all covered by Swift Testing.
A StoreKit 2 Paywall From Scratch: Subscriptions, a Transaction Listener, and a Restore Button That Works
Day 15 of the 30-day iOS series, first of a three-part run on monetization. I built BrewLog's real paywall with StoreKit 2 — two subscription products, a transaction listener, and a restore flow — with zero third-party SDKs. Every number the paywall shows comes from one pure, tested function.
SwiftData Two Years Later: What's Solid, What Still Bites, and the Migration Test You're Not Writing
Day 14 of the 30-day iOS series. SwiftData is about two years old now, and the honest verdict is mixed. I already wrote the long field report on where it broke in production — this post is the part that report didn't have room for: a VersionedSchema + SchemaMigrationPlan test that proves a schema change is safe BEFORE TestFlight finds out for you.
@Observable vs ObservableObject: What 1,000 Rows and a Redraw Counter Actually Showed Me
Day 13 of the 30-day iOS series. I built a redraw counter into BrewLog, put 1,000 rows in two identical lists side by side — one backed by @Observable, one by ObservableObject — and toggled a single favorite ten times. The row counts tied 10-10. The list counts didn't. Here's the real number, and exactly where it comes from.
@State, @Bindable, @Environment: The Complete Map for @Observable (and the Question You're Actually Asking)
Day 12 of the 30-day iOS series. With @Observable, SwiftUI lets you slap @State, @Bindable, @Environment, or a plain let on the same class — and compiles all of them. Here's the question that actually decides which one is correct, one map that resolves 95% of the confusion, and three real BrewLog bugs (one silent, one a compile error, one a runtime crash) that come from picking wrong.
ObservableObject → @Observable: The Migration Guide That Skips the Marketing (and the Autoclosure Gotcha Apple Forgot to Mention)
Day 11 of the 30-day iOS series. Apple's migration guide makes ObservableObject → @Observable look like a find-and-replace. It mostly is — except for one quiet behavioral change: @StateObject only ran your initializer once, and @State runs it on every render. Here's the multiple-init bug that causes, why it's worst in exactly the init you were proud of, and how to fix it with a test that turns 'no side effects in init' into a hard, green invariant.
ThinkBud + Foundation Models: What I Shipped On-Device, and the Wall That Sent Me Back to the Server
Day 10 of the 30-day iOS series, the build-in-public finale of AI week. I took the on-device Foundation Models stack from Days 8 and 9 and bolted it into ThinkBud, an app I actually ship. Here's the honest field report: the bounded tasks the on-device model nailed for free and offline, the context-window wall a 100K-character textbook import smashed into, and the exact line of code where I gave up and routed to a server. Plus the one decision that's pure Swift — so it gets a real test.
Tim Cook Wiped a Tear, Siri Got a Google Brain, and Apple Shipped a Transparency Slider. WWDC 2026, Honestly.
The WWDC 2026 keynote just happened. Tim Cook's emotional farewell, Siri rebuilt on Gemini, Core AI replacing Core ML, Xcode 27 going full MCP, and Liquid Glass finally getting a slider. Here's what actually matters for your iOS codebase — no press release fluff.
@Generable: Make Apple's On-Device Model Hand You a Swift Struct, Not a String to Parse
Day 9 of the 30-day iOS series, part 2 of AI week. Yesterday Foundation Models gave us a String. Today we make it give us a typed Swift value — BrewSummary(flavor:, advice:, rating:) instead of a paragraph you regex your way through. @Generable, @Guide constraints, session.respond(to:generating:), and the sleeper-within-the-sleeper: tool calling, where the on-device model calls your own Swift code mid-answer. With the TDD seam, because typed output changes what you test.
Foundation Models: Your First On-Device AI Feature With No Backend, No API Key, No Bill
Day 8 of the 30-day iOS series, and the start of AI week. The Foundation Models framework runs a real language model entirely on the phone — free, private, offline. We build the smallest thing that works: summarize a block of text in three lines, handle the availability cases that bite in production, wire it into a real app, and put a TDD seam around the part that isn't the model. Code-along, with tests.
UIDesignRequiresCompatibility: When (and Why) Opting Out of Liquid Glass Is the Pro Move
Apple hands you one Info.plist key that freezes the old design for a full year. It's not a cop-out — for banking, enterprise, and apps caught mid-redesign, opting out of Liquid Glass is the responsible call. The exact flag, a real before/after from my own app, the deadline, and a decision matrix you can actually defend in a standup. Plus the per-screen rollout gate you should be testing instead.
Icon Composer and the New App-Icon Era: One Document Instead of Three Exported PNGs
iOS 26 wants your app icon in light, dark, clear, and tinted. The old way was three flat 1024px PNGs that quietly drifted apart. Icon Composer turns it into one layered .icon document the system relights for you. The real workflow from a single SVG to a full set — plus the one decision around icons you can actually unit-test.
Custom Liquid Glass Components: When to Leave the Defaults (and the Three Mistakes That Kill Your Frame Rate)
glassEffect(.regular, in:) with a custom shape, two glass blobs that morph into each other with glassEffectID, and the three things that turn buttery Liquid Glass into a stutter machine. Built on a real iPhone 17 Pro simulator, with the TDD seam that keeps the decision testable even though the render isn't.
Tim Cook's Curtain Call: His Last WWDC Keynote and What Changes for Every iOS Developer
Tim Cook delivers his final WWDC keynote on June 8 before handing the CEO role to hardware chief John Ternus on September 1. After 15 years, a $350B-to-$4T run, and a developer ecosystem of 2.3 billion devices, here's what the transition actually means for people who write Swift for a living.
Liquid Glass for an App You Already Shipped: What You Get From a Recompile vs. Five Lines of Tuning
I rebuilt a real SwiftUI app against the iOS 26 SDK and took two screenshots of the exact same screen — one with zero code changes, one with five lines of glassEffect. Here's the honest split between what the recompile hands you for free and what's worth your custom-tuning time, plus the TDD seam that makes a visual feature testable.
Apple Said 'All Systems Glow.' Developers Said 'Not So Fast.'
Apple dropped its WWDC 2026 tagline yesterday and the developer forums immediately caught fire. Half the community is excited for iOS 27's AI overhaul. The other half is already mourning the operating system they used to love. With six days until the keynote, here's what the divide tells us about where Apple is headed.
Migrating a Real App to Swift 6.2 Strict Concurrency: 86 Errors, One Afternoon, One Race Condition I Didn't Know I Had
I migrated Invoize from Swift 6.0 strict mode to Swift 6.2 approachable concurrency on a Sunday afternoon. Every warning, every fix, the one real race condition the compiler finally surfaced — and the TDD seams I leaned on so the migration wasn't just compiler-driven guessing.
@concurrent vs nonisolated vs @MainActor: The Swift 6.2 Decision Tree That Fits on a Napkin
Four real scenarios — UI update, network call, image decode, file IO — and exactly which Swift 6.2 isolation keyword each one needs. A TDD walk-through with Swift Testing, no whiteboard ceremony required.
Apple Is Turning Every App Into an AI Tool — MCP Support Means Siri Was Just the Warm-Up
Apple is building native Model Context Protocol support on top of App Intents. That means Claude, ChatGPT, Gemini, and every other AI agent will be able to control your app — not just Siri. Nine days before WWDC 2026, here's what this means for iOS developers and why your App Intents just became the most important code you've ever written.
MainActor by Default: Why Apple Just Reversed Swift's Concurrency Story
Xcode 26 flips the default — your code now runs on the main actor unless you say otherwise. Here's why Apple changed direction, what it actually means for your existing project, and a TDD walk-through showing the migration in real Swift.
Google's AI Is About to Run on Every iPhone. Apple Thinks That's a Feature, Not a Bug.
Apple is training distilled versions of Google's Gemini to run directly on iPhones. For iOS developers, this means your Foundation Models code might soon be powered by Google under the hood — and WWDC 2026 will make it official. Here's what changed, why it matters, and what to build before June 8.
Apple Registered genai.apple.com. Twelve Days Before WWDC, the Biggest Clue Just Dropped.
Apple quietly registered a GenAI subdomain last week. It's not live yet, but the timing — twelve days before WWDC 2026 — tells us everything about where the iOS developer platform is headed. Core AI, Siri Extensions, Foundation Models, and a public-facing AI hub. Here's what it means for your next project.
Your Bug Fix Is Behind 235,800 Vibe-Coded Apps. Welcome to App Review in 2026.
App Store review times ballooned from under 24 hours to multi-week waits after vibe coding drove an 84% surge in submissions. Indie developers with critical bug fixes are stuck behind a flood of AI-generated apps. Here's the data, the developer stories, and what you can actually do about it.
I Wrote Swift in Cursor for a Week. Xcode, We Need to Talk.
Swift officially hit the Open VSX Registry — meaning Cursor, Kiro, and every AI IDE now support Swift with full LSP, debugging, and test explorer. I spent a week building iOS code outside Xcode. Here's what worked, what didn't, and why Apple publishing a Cursor setup guide is the most understated power move of 2026.
Apple Is Building an AI App Store Inside Siri. Most Developers Haven't Noticed Yet.
iOS 27 will turn Siri into a chatbot with third-party Extensions — a dedicated App Store section for AI integrations. This is the biggest new distribution channel since widgets. Here's what indie iOS developers should be building right now.
Swift Has 217 Keywords Now. Nobody Agrees on What It's For.
Swift started as a simple, elegant language that composed beautifully. Twelve years later, it has 217 keywords, a governance problem, and an identity crisis. With WWDC 2026 weeks away, the community is asking: is Apple killing its own programming language?
Apple's WWDC 2026 Invite Says 'Coming Bright Up' — We Decoded Every Pixel
The WWDC 2026 media invites dropped yesterday with a glowing Swift logo and the tagline 'Coming Bright Up.' Here's what Apple is really telling us about Siri 2.0, the Gemini partnership, and what iOS developers should prepare for in the next 20 days.
Your Xcode Has a Built-In MCP Server. Most iOS Developers Haven't Noticed Yet.
MCP is the protocol that lets AI tools talk to everything — your code, your simulator, your build system. Xcode 26.3 shipped one quietly. There's an official Swift SDK. And WWDC 2026 might make it the backbone of CoreAI. Here's what iOS developers need to know before everyone else figures it out.
Visual Intelligence Is the Sleeper Hit of WWDC 2026. Most Developers Don't See It Coming.
Apple is opening Visual Intelligence to third-party developers at WWDC 2026 — nutrition scanning, contact capture, Wallet passes, and a full camera AI pipeline. While everyone argues about Siri, this is the API that will actually change how your app works. Here's what we know and how to prepare.
Xcode 26.5 Just Made Its AI Agent Less Annoying. Is That Enough?
Xcode 26.5 shipped two small features — message queuing and clarifying questions — that fix the most frustrating parts of agentic coding. Here's what actually changed, why it matters more than it sounds, and whether Apple's AI coding agent is finally ready for your daily workflow.
Apple Wants You to Move Into Siri's New House. Read the Lease First.
iOS 27 turns Siri into a full chat app with conversation history, document uploads, and deep app integration. Apple is courting developers to build for it — but won't promise it won't charge commission later. Here's why some developers are hesitating, and what you should actually do.
WWDC 2026 Is 26 Days Away. This Is Your iOS Developer Pre-Flight Checklist.
WWDC 2026 lands June 8. SiriKit deprecation, Core AI replacing Core ML, Liquid Glass refinements, foldable iPhone APIs, and strict concurrency in Swift 7. Here's the practical pre-flight checklist to run through your codebase right now — before the keynote makes it urgent.
App Intents Are the New SEO — and Most iOS Developers Are Still Invisible
Siri is becoming the front door to every iPhone. App Intents are no longer a nice-to-have — they're the difference between discoverable and dead. Here's a practical guide to making your app visible before WWDC 2026 changes the rules.
iOS Interviews Are Broken in 2026 — And Everyone Knows It
Companies test you on raw Swift memorization while their production code is 40% AI-generated. The iOS interview process in 2026 is a theater performance nobody believes in anymore. Here's what's actually wrong and what should replace it.
Swift 6.3 on Android, Three Weeks In: What Actually Broke and What Surprised Me
When Apple shipped Swift 6.3 with first-class Android support last month, I bet a Saturday on porting a piece of ThinkBud's sync engine to Android. Three weeks of usage later — here's what stuck, what didn't, and the one bug that taught me more than a year of Swift Concurrency reading.
Swift 6.2 Finally Made Concurrency Approachable — Someone Already Built a Parody Site
Swift 6.2 ships @MainActor by default, the new @concurrent attribute, and a complete rethink of strict concurrency. We break down what changed, show real migration code, and explain why the community is both celebrating and arguing.
Claude Code vs Cursor: I Used Both for a Month. One Tried to Charge $1,400.
Cursor is the sous chef who hands you the knife before you ask. Claude Code is the contractor who remodels your kitchen overnight. We tested both on real iOS projects and here's when each one wins — plus how to avoid that terrifying billing surprise.
Swift 6.3 Now Officially Runs on Android. I Tried It. Here's What Actually Works.
Apple shipped an official Swift SDK for Android with Swift 6.3. Not a hack, not a community port — the real thing. We tested it on a real project and here's every win, every friction point, and the honest verdict on whether iOS developers should care.
Apple's iOS 26 SDK Deadline Hits Tomorrow. Half the App Store Isn't Ready.
April 28, 2026 — every app submitted to the App Store must be built with Xcode 26 and the iOS 26 SDK. If you haven't updated yet, your next submission gets rejected. Here's what's breaking, what you need to fix, and why this deadline is different.
We Gave Claude Mythos Full Access to Our Codebase. It Shipped Three Features Before Lunch.
After a week of security testing, we let Anthropic's most restricted AI model loose on real development work. It refactored our state management, found a memory leak we'd chased for months, and rewrote our networking layer across four apps. Week two was a different beast.
Apple Is Shipping Foldable iPhone APIs Before the Foldable iPhone. That's Either Genius or Chaos.
WWDC 2026 drops June 8. Apple is giving developers fold-state detection, Core AI replacing Core ML, macOS touch APIs, and a Siri that lives in the Dynamic Island. Here's what you need to know and what we're already building.
Apple Put a 3-Billion Parameter Brain Inside Every iPhone. Most Developers Haven't Even Noticed.
Apple's Foundation Models framework lets you run AI on-device with 3 lines of Swift. No API keys. No cloud bills. No privacy headaches. Here's why iOS developers should stop ignoring the smartest thing Apple shipped in years.
Apple Stopped Pretending It Could Build AI Alone. That's the Best WWDC News in Years.
WWDC 2026 is two months away. Apple is opening Siri to Claude, Gemini, and Grok. Xcode already has agentic coding. iOS 27 is a stability year. Here's what iOS developers actually need to care about.