[The Mobile Report] Issue #3: WWDC 2026 Survival Guide

Every year WWDC has lots of great videos but who has the time to watch all of them!? This is a survival guide that filters and distills what mobile engineers really need to watch and pay attention to.

Apple released 138 WWDC sessions this year. Of course, not all of them are useful to us mobile engineers. I went through all of them to distill only what you really need to know about and watch. I’m calling it a survival guide to WWDC because lately I’ve been into jungle metaphors and rewatching the Indiana Jones movies (I had so much fun with this theme that even created a fun custom page for this issue https://mobileengineer.io/the-mobile-report/3/wwdc-2026-survival-guide).

At the end of the day, what really matters is about 24 sessions, and this issue is a guide to help you figure out exactly what you’d want to spend your time digging into and watching yourself.

WWDC is obviously all about AI this time. Apple has not tried to join the hyperscaler race to build data centers and compete on the best model like everyone else. Maybe they just cannot make their own model, or maybe they are smarter than the rest and playing the long game, the one where the model gets commoditized and the hardware, the OS, and the apps are what win in the end. No one knows yet. But what they showed this year makes me think it might be the latter, because they are making good moves: they are letting us third-party developers integrate with the system and the Siri agent far more ergonomically than I expected. These new integrations through App Intents and the other iOS system APIs and extensions feel like the thing that keeps us app developers out of the rabbit hole everyone has been falling into lately, where you bolt your own “agent chat interface” onto your app and it turns out to be subpar crap almost every time.

Basically, now you can integrate your app deeply with Siri: expose your app’s data so Siri can discover it and show it to the user, and give Siri a list of actions your app can perform when it asks, on the user’s behalf. There is also more for running local models and orchestrating their behavior. Maybe, just maybe, not all of our apps will turn into a chatbot interface.

The thing we need to worry about more now is how to get all that data into Siri and Spotlight. Mobile apps can only hold so much data locally, and you will not always get the chance to run a full backend fetch (although there is an option for long-running tasks with Live Activities), so now we have to think harder about background fetch jobs, periodic refresh, offline storage, and the rest. More system-design thinking, which I think is good for us mobile engineers.

With more and more AI usage in software in general, the main bottleneck and concern is token cost. A lot of tech companies these days seem to be trying to either pass the compute cost down to their users by charging for tokens, or just eat the cost, usually by degrading quality or limiting how much AI usage you get. Apple is encouraging third-party developers to use more AI in our apps, but the same issue arises. So it seems like they are trying to pass the cost down to the consumer directly, by making them pay for iCloud to get extra AI usage, rather than having us devs come up with a solution and figure out how to charge for it. On one hand it is great, because we devs do not have to worry about as much, but on the other hand they are making this whole thing play in their favor and charging users more for iCloud. I am not sure how it ultimately plays out, because users might get confused by two bills, one from the app and one for iCloud, but we shall see.

Of course, as always, there are a lot of little things and updates, like SwiftUI and Swift. The thing is, I am not very impressed with them, but they are nevertheless something we need to pay attention to, since we code for iOS. Specifically, I am disappointed that we keep getting interop improvements between AppKit and SwiftUI, but there is still nothing between UIKit and SwiftUI. Where is my UIHostingView, the UIKit equivalent of NSHostingView?!

I still live in Claude Code day to day and practically never open Xcode anymore. Even with all the changes and everything Apple tried this year, I do not think I am switching back yet. That said, I think Apple finally showed some interesting changes in the platform and the tools they have for us developers at this year’s WWDC.

AI-Augmented Development

This is basically what the lion’s share of the WWDC was all about - make your apps more agentic/LLM fused.

What’s new in the Foundation Models framework

These two are pretty good, and you want to watch this one together with its agentic follow-up. Apple is finally giving us a solid baseline framework for using models in our apps. The main idea is profiles: you switch the system prompt for each round of the conversation, driven by your actual application state, so it stays deterministic instead of LLM probabilistic guessing. They give us a structure to put things in, a place for our tools, and evaluation tools to check it all. And Claude and Gemini now sit behind the same API as Apple’s own models. There is going to be a new wave of app features built on this kind of agentic stuff, and every iOS developer should look into it.

Build with the new Apple Foundation Model on Private Cloud Compute

The on-device model caps you at 8K of context, which is fine until it is not. Private Cloud Compute bumps you to 32,000 tokens for free, and moving to it is a one-line change from the on-device model, with the same structured output and tool calling. Still not huge, but enough for smaller apps and datasets. The catch is who pays for all that free compute, which seems to be the user, not devs.

LLM search using Core Spotlight

Pretty clever, and pretty cool. You get local retrieval-augmented search without standing up a vector database: index your content in Spotlight, hand a search tool to the model, and let it query your own data to answer questions in plain language. This is probably what finally gets me to look at Spotlight for my apps. I never had a reason before, as a user or a developer it just was not useful, and the most I ever got out of it was a shortcut into some deeper deep-linked screen instead of the launch screen. An LLM sitting on top of that index, grounded in your data, suddenly makes it worth a look. We shall see.

Build AI-powered scripts with the fm CLI and Python SDK

This one is simple: Apple gave us command-line and Python tools to run their models outside of an app. The fm command-line tool ships in macOS 27, so you can call the on-device model straight from your terminal or a shell script, feed it an image, or point it at the bigger cloud model. There is also a Python SDK, which is the useful part for me, since it lets you build and run eval pipelines in a notebook to test how your prompts actually perform. Good, practical tooling for running evals. Nothing deeper to read into it.

Meet the Evaluations framework

Good stuff, and I want to dig into this myself. Sounds like they took the performance testing we already had, where you run your code multiple times, get several rounds of data, average them, and compare to a baseline, and if it drops below the baseline the test fails. Now this concept applied to evaluating models and prompts that you run in your app. The agentic version goes a level deeper and checks the tool-call path itself, not just the final answer, and the hill-climbing session is the method around it: change one thing, compare, repeat. Neat.

Run local agentic AI on the Mac using MLX

MLX lets you run open models locally on your Mac, and even cluster a few Macs together to run or fine-tune bigger ones. This is not exactly mobile development, but it’s worth a look, because I think more and more of us are going to want local inference over time, and maybe even to train our own models. I sure do.

App Intents & Siri

This is, imo, the most important stuff from the entire WWDC this year: how do we integrate with Siri and Spotlight as it all got way more powerful and agentic. I encourage every mobile engineer to study these videos.

Build intelligent Siri experiences with App Schemas

Apple is giving us exactly what it should here to integrate deeply with the system and the new agentic side of Siri, and I like what I see. You index your content so Siri can find it, Siri pulls what it needs on a request, and then it runs your actions in your own code, where you can do a local database change or call your backend. There are also new capabilities in the App Intents session like long-running intents, stable cross-device IDs, and cheaper bulk entity handling, and the advanced session lets you mark an entity as private or shared so Siri asks before doing something destructive to shared data, in case the model gets it wrong. All great stuff.

But indexing is not the same as fetching the data. You push a slice of your data into the on-device Spotlight index so Siri can find and rank it, but the system never reaches into your backend itself. When the user asks for something, the system launches your App Intents extension and calls your query code, and that’s when you go get the data, from local storage or your backend. So the system never pulls your data for you. Your own code does it, when Siri asks.

What’s new in Shortcuts

Small session, but there’s one useful tool in it. Shortcuts now has a model transcript inspector that shows you the exact data your App Intent entities expose to the model. That sounds boring until the first time the model does something dumb with your data and you have no idea why. Their example: the model couldn’t find spicy dishes because the entity only exposed a name and availability, not ingredients. The inspector revealed it quickly. Very useful for debugging your app intent entities and what data they actually expose.

Live Activities essentials

This is a good one too, because now the Live Activity is much more important for running the long-running tasks your app performs when triggered from Siri. You get progress and a way to stop it.

Xcode & Tooling

Xcode, agents, and you

The plan, build, test agent loop is kind of boring. Sure, it is nice that we finally have it inside Xcode, but you could be running exactly this in Claude Code for a long time now. Hook up all the MCPs like XcodeBuildMCP and you don’t even have to open Xcode at all.

Build, deliver, and automate with Xcode Cloud

Not a ton new in Xcode Cloud this year, but two things are quite useful. Webhooks - build-created, build-started, and build-completed events can hit your own endpoint and feed a dashboard or a Slack channel. There is also the additional repositories manager, so you can pull several Git repos into one build for a modular setup. The rest is just a nicer setup wizard. There is still no way to automate this stuff - no MCP, or CLI, nothing an agent can use. I just want my clanker (agent) to do this kind of plumbing setup for me! But alas what we got is more clicking in the UI.

Create UI prototypes using agents in Xcode

Interesting to check out what Apple did here. It’s all built on SwiftUI previews: an agent spits out a dozen variations and you pick one, and Apple swears the code it gives you is production-ready and something you’d actually ship. Nope. I have never seen a production codebase where the code is structured nicely like that for previews to even work. Not going to happen, even (or especially so) if AI writes it. This is a nice “apple-wants-it-that-way-but-real-world-development-disagrees” type of thing, just like storyboards were.

Mobile at Scale

Validate your App Intents adoption with AppIntentsTesting

Good stuff, and I’m glad they’re finally putting real effort into testing intents. Anyone who has tried to test extensions and the other out-of-your-app-process stuff knows what a pain it has always been. Now you get a proper way to test your App Intents without fighting the process boundaries. If you are wiring up Siri, this is the one that catches your mistakes before your users do. It pairs nicely with the Evaluations work above: one tests your intent plumbing, the other tests your model output.

Two smaller tooling upgrades

Migrate to Swift Testing finally lets Swift Testing and the old XCTest call into each other, so you can move over piece by piece instead of rewriting the entire suite in one go, and parameterized tests run in parallel by default now. And the rebuilt MetricKit is Swift-first, shipping your metrics as plain data you can send straight to your backend, with a new per-screen reporting mode that tells you which part of your app is slow instead of blending everything into one useless average.

Architecture & Design Patterns

Use SwiftUI with AppKit and UIKit

I still need to dig through the docs before I say anything final, but from the session alone, UIKit got no love again. There is still no UIHostingView, so embedding SwiftUI in a UIKit app still means wrapping it in a child view controller, while AppKit just gets a nice NSHostingView that can be embedded anywhere without much ceremony or plumbing. Apple keeps saying shared foundation. On iOS, it stays just words until they ship a UIHostingView.

Modernize your UIKit app

This one made me a little sad. Apple is pushing iOS apps to behave like responsive web pages that reflow across phone, tablet, and desktop, and they are trying to shove it down our throats. It does not work for mobile apps and I think Apple really doesn’t get how so. An iPhone app, an iPad app, and a Mac app do not merely have different layouts. They have different navigation, different state, different use cases, different interactions, and a different user experience. Stretching one thing across all three and calling it finished is fitting a square peg in a round hole. It will break, and it will break in the ugliest way possible, at scale, in production. A phone codebase should be separate from a tablet codebase and from a desktop one, and so should the UI, the layout, and the UX. I need to write up about this in detail. Doesn’t seem like web devs understand this (responsive layout is a huge mistake, mobile web ≠ desktop web) nor does Apple.

Conclusion

This WWDC was exciting for a change - Apple finally gave us more AI stuff and a promising way to integrate our apps with the overall agentic Siri system. There are a lot of sessions as usual, but I hope this distillation helps you filter out and watch only what really matters to you. Let me know what your favorite sessions are in the comments, I’d love to hear about them!