WWDC26: Everything That Changed for Developers

The thing you notice at WWDC, sitting in the room at Apple Park, is that the conversation skips the iPhone updates almost entirely. Everyone's already on the APIs. People can't wait to get the betas onto their devices, and plenty already have apps lined up, ready to build the new features the moment they can. That's the half of WWDC that doesn't make the recaps, and it's the half that changes my actual work.

This was my fourth WWDC and my first in person since 2017, so I'm covering both halves here. The consumer side first, since it's the context for what we get to build with, then the part that quietly changes how you ship.

The consumer side, quickly

Siri got rebuilt. This is the headline. The new Siri has a system-wide understanding of personal context and on-screen awareness, the thing Apple promised back in 2024 and didn't deliver until now. It's powered by a custom Google Gemini model running in the cloud for the heavy queries, with on-device handling for the rest.

One detail worth being precise about, because a lot of coverage gets it wrong. Gemini is doing the work for complex Siri requests, but Apple's own on-device models still handle a lot, and the developer-facing framework is a separate story from the consumer Siri. I'll get to that.

It's a cool step in the right direction, and it genuinely helps when you're using Siri. The thing I'm still working out is how it shares resources with the apps I build. As far as I can tell, Siri's heavy queries and the AI features you ship into your own app both draw on the same Private Cloud Compute limits. If that's right, a user leaning hard on the new Siri could eat into what's left for third-party AI features. I don't have a confirmed answer yet, but it's the question I'd want resolved before betting a feature on it.

iOS 27 is a refinement year. Liquid Glass got a second pass, including a personalisation slider so you can tune how transparent the interface is. Shipping a bold visual direction is the easy part. Getting it right across hundreds of millions of users a full year after you launched it is the hard part. The slider is the honest in-between, letting people dial it to where it actually works for them rather than Apple picking one answer for everyone. Search got rebuilt under the hood too, across Spotlight, Mail, and Photos.

Then a long list of smaller wins: independent alarm volume, custom EQ for AirPods, perimenopause and menopause tracking in Health, CarPlay video apps. The kind of release that doesn't demo loud but fixes a lot.

It runs on almost everything. iOS 27 supports iPhone 11 and later. The Apple Intelligence and Siri AI features need newer hardware (iPhone 15 Pro or 16 and later), but the base update reaches further back than most.

It was also Tim Cook's last WWDC keynote as CEO. John Ternus takes over on September 1.

The developer side, which is the real story

Here's where it gets interesting if you build. Four things matter, and they compound.

1. Foundation Models grew up

Apple introduced the Foundation Models framework last year. It was the native Swift API for talking to the on-device model that powers Apple Intelligence. Useful, but limited enough that a lot of people filed it under "worth trying" and moved on.

This year it became the thing it was always going to be. The framework is now a single Swift API that talks to the on-device model, to Apple's Private Cloud Compute, and to third-party clouds like Claude and Gemini, all through one call site. Any provider that conforms to the Language Model protocol plugs in. In practice that means you can prototype a feature on the on-device model and route the harder queries to a bigger cloud model by changing a dependency, without rewriting your feature code.

A few more additions that matter:

• Image input. You can pass images alongside text now, so the model can reason about visual content. Vision framework tools like OCR and barcode reading are callable by the model directly, on-device.
• Dynamic Profiles. Swap models, tools, and instructions on the fly inside one continuous session. This is Apple's primitive for building agentic, multi-step experiences.
• Free Private Cloud Compute access if you're in the App Store Small Business Program and under two million first-time downloads. No keys, no per-token bill. That removes the main cost barrier to shipping a real AI feature for most indie and small-team apps.
• It's going open source, with a Python SDK and an fm command line tool so you can prompt the model from the terminal.

Where I can see this being genuinely useful is anywhere you want fast AI results as a processing step without your users burning through your own API limits. On-device or free Private Cloud Compute handling the quick, high-volume work is a real shift in what's affordable to ship.

The model-swap piece is the part I'm most interested in, but it's also the part that's too early to call. Nobody's benchmarked the on-device and PCC models properly against the cloud models yet, and the practical limits on Private Cloud Compute aren't clear. I don't think Apple fully knows them yet either. A lot of that gets answered during the beta period based on real usage, so my honest position is that this has real potential and I need to actually build with it before I'll say more than that.

2. The Evaluations framework

This is the one I care about most, and it's the one almost nobody is talking about yet. I'm keeping it short here on purpose, because the full walkthrough on a real feature is coming and it needs the room.

When you build a feature with a language model, you break a rule that all of software testing is built on. The same input no longer produces the same output. A unit test assumes determinism. Generative features don't have it. So the question stops being "did this function return the right value" and becomes "how often does my feature produce a good result, and did my last change make that better or worse."

That's not a prompting problem. It's a measurement problem. And until now you mostly measured it by eyeballing outputs and hoping.

The new Evaluations framework is Apple's answer. It's a Swift framework, new in Xcode 27, that lets you build a dataset of test cases, define what "good" means with quantitative metrics, and for the fuzzier stuff, use a second more capable model as a judge to score outputs against dimensions you define. You run it, you change a prompt, you run it again, and you watch the score move. Apple calls the loop "hill-climbing."

I want to take this further on a real feature, because it deserves more than a paragraph and because you can't really explain evals without showing them on something that actually exists. More on that to come.

3. App Intents is now the only door into Siri

This is the one with a deadline, so read this part even if you skim the rest.

App Intents is the Swift framework that lets your app expose its actions and content to Siri, Spotlight, and Shortcuts. At WWDC26, Apple gave SiriKit a formal deprecation notice and made App Intents the only way the new Siri can reach into your app.

What that means in plain terms. If your app's voice features are still built on SiriKit, your app will compile under iOS 27, but it will not show up in the rebuilt Siri that ships to everyone this fall. You get deprecation warnings rather than errors, so it's easy to miss. There's a two-to-three-year runway before SiriKit is removed entirely, but the visibility problem starts in September.

Apple also added real tooling around this. Entity schemas that contribute your content to the Spotlight semantic index, a View Annotations API to map on-screen views to entities so people can act on what they're looking at, and an App Intents Testing framework so you can validate the whole integration without UI automation.

If you ship an app with any voice or Shortcuts surface, auditing your SiriKit usage is the highest-priority thing on your list right now.

4. Core AI and Xcode 27

Two more worth knowing about.

Core AI is a new, separate framework for running your *own* models on-device. A lot of the coverage conflated this with Foundation Models, but they're different. Foundation Models is for talking to Apple's models and third-party providers through one API. Core AI is the lower-level framework for loading, specialising, and running custom models directly on Apple Silicon, with fine-grained control over memory and zero token cost.

Xcode 27 went agentic. On-device predictive code completion now runs on the Neural Engine, so your source never leaves your Mac for a completion. On top of that, coding agents can drive the simulator, run tests, and fix crashes from Organizer, with the option to route heavier work to Claude, Gemini, or OpenAI models that you opt into. There's also a bridge that exposes Xcode's live state (diagnostics, symbols, SwiftUI previews) to external MCP agents, which is its own rabbit hole. Something I want to dig into properly another time.

What I'd actually do with this

If I'm prioritising, the order is:

1. Audit SiriKit now. It's the only item with a clock on it.
2. Try the free Private Cloud Compute tier if you qualify. The cost barrier to a real AI feature went to zero for most small apps.
3. Set up evals before you ship anything generative. If you're shipping AI features without measuring them, you're making changes blind. This framework is the cheapest insurance there is.
4. Watch Core AI if you're running custom models. Less urgent, but it's where on-device ML is heading.

If I had to point at the one thing most developers will sleep on, it's App Intents. Not just because of the deprecation clock, though that's real. It's because App Intents is the actual groundwork for agentic apps. Right now a lot of apps call themselves agentic but still need the user to take the action. App Intents is what lets the assistant take the action for them, properly hands-free. That's the direction everything is moving, and the apps that expose their core actions early are the ones that'll be ready for it. This is not the one to put off.

I'll be going deeper on a few of these soon, evals especially. If that's your thing, stick around.