iOS 27 for Indie Developers: What Changed at WWDC 2026

You watched the June 8 keynote. You started a "WWDC 2026 watchlist" with thirty sessions on it, got through four, and now it's a month later and the only thing you remember is that Siri got rebuilt and somebody said "agentic" a lot. Same.

This is the cheat sheet we wish we'd had as small-team developers staring down iOS 27. It's in beta now and ships this fall alongside iPadOS 27, macOS 27 Golden Gate, watchOS 27, and visionOS 27. Not every new API matters to you. A few genuinely do.

What Apple actually shipped in iOS 27

Strip away the keynote choreography and iOS 27 lands on four themes for indie developers: Foundation Models, App Intents, App Store subscription mechanics, and SwiftUI and Xcode 27 maturity work — including two source-breaking changes to know about before you rebuild.

Everything else — the rebuilt system-wide search, the CPU scheduler work that makes older devices feel quicker, Container Machines for Linux containers on macOS — is real, but it's not where most indie teams should spend their first quarter.

Foundation Models: Apple just made cloud AI free for small devs

The Foundation Models framework arrived with iOS 26 last September and handed you the on-device Apple Intelligence model from Swift: free, private, offline. Good, but small — it handles summarization and classification well and falls over on real reasoning.

At WWDC 2026 Apple extended that same API to its cloud models on Private Cloud Compute — and then made them free. If you're in the App Store Small Business Program with fewer than two million first-time downloads, you can call Apple's latest cloud model with no API key, no per-token pricing, and no monthly bill. For a solo developer paying an external provider by the token, that's a line straight through your inference cost.

The framework picked up three other things worth knowing:

• Image input on the on-device model, which opens up receipt parsing, label reading, and photo triage without a server.
• Custom skills and Dynamic Profiles — swap models and tools at runtime instead of hard-coding one path through your AI feature.
• A public LanguageModel protocol. Third parties implement it, so Claude and Gemini models sit behind the same Swift API as Apple's own. Apple also said it will open source the framework.

That last point is the strategic one: write the feature once and swap what's behind it later. Given how fast model pricing moves, portability beats any single model's quality today.

The catch is still hardware. Apple Intelligence needs an A17 Pro chip or newer, so iPhone 15 Pro and later, while iOS 27 itself runs back to iPhone 11. The most powerful on-device model wants an iPhone 17 Pro or iPhone Air. Treat AI as a layered enhancement, and never gate core functionality on it.

App Intents is the new front door, and SiriKit is on the clock

If you remember nothing else from WWDC 2026, remember this: Apple formally deprecated SiriKit, and App Intents is now the only framework the rebuilt Siri uses to call into third-party apps. Spotlight uses App Intents. Shortcuts uses them. Widgets and Live Activities lean on them.

The timeline is not a cliff. Apple signalled roughly a two-to-three-year support window, and old INExtension code still compiles against iOS 27 with deprecation warnings. But SiriKit apps don't surface in the new Siri at all, so your real deadline isn't the removal date. It's the day users expect Siri to reach into apps and yours isn't there.

App Intents itself got more capable: richer entity types, streaming responses, multi-turn follow-ups, App Schemas so the system understands what kind of app you are, and a View Annotations API that maps on-screen elements so users can reference them out loud. A new AppIntentsTesting framework validates intents through the real Siri, Shortcuts, and Spotlight pathways instead of UI automation.

The practical implication: design App Intents at the start of a feature, not at the end. Every user action should have an intent shape describing it. If you're shipping your first iOS app, the order of operations in how to publish an iOS app in 2026 still applies — just slot intent design between architecture and UI.

Apple gave indie devs a free AI runtime and a two-year migration deadline in the same keynote. Most of them noticed neither.

App Store subscriptions got new levers

The monetization changes got about ninety seconds of stage time and matter more to a small business than half the framework news:

• Cross-developer Bundles. For the first time you can partner with another developer and sell a combined subscription spanning apps you don't own.
• Suites. A step past bundles: a set of subscriptions sold only as a package, not available standalone.
• Retention messaging. Reach a subscriber the moment they tap cancel, with your own copy, imagery, and an optional save offer.
• Grouped in-app purchase submissions. App Store Connect now takes multiple IAPs, subscriptions, and in-app events in one submission instead of one painful review at a time.

None of this changes Apple's cut, and the structural gripes in Apple's 30% tax haven't gone anywhere. But retention messaging is worth an afternoon for most subscription apps.

SwiftUI and Xcode 27: boring wins, plus two things that will break

SwiftUI didn't get the keynote energy this year, and that's mostly good news. Most of the iOS 27 work is polish that quietly deletes workaround code:

• Reorderable containers. .reorderable() brings drag-to-reorder to LazyVStack, LazyVGrid, and custom layouts.
• Swipe actions outside List via swipeActionsContainer(), so you stop rebuilding List just to get a swipe.
• AsyncImage finally caches, honoring standard HTTP cache headers with no code change.
• Better toolbars: visibilityPriority(), an overflow menu, and toolbarMinimizeBehavior() to collapse the nav bar on scroll.

Two changes are source-breaking, so read this before you rebuild. @State is now a macro rather than a property wrapper, and classes stored in state initialize lazily, once per view lifetime. And result builders unified under ContentBuilder, which can introduce ambiguity in overlay() and background() calls that pass a ShapeStyle. Neither is hard to fix. Both will surprise you if you budgeted zero hours for the SDK bump.

Xcode 27 runs code completion on the Neural Engine, so your source never leaves the machine, and the coding assistant can drive the Simulator. None of it is "rewrite your app" material. If you're on UIKit and shipping, stay there and adopt SwiftUI opportunistically — full rewrites are still the most common way for indie teams to wreck a roadmap, as we cover in smaller launches, bigger wins.

The pattern Apple has rewarded for the last few cycles holds: platform-level integrations (intents, system AI, system-wide surfaces) compound over time. New framework demos rarely do. When in doubt, invest where Apple is investing.

What this means for your roadmap

If you're already shipping, here's the practical sequence we'd use this cycle:

• Install Xcode 27 and build clean against the iOS 27 SDK. Expect @State and builder-ambiguity errors. Fix them on a quiet afternoon, not in September while users are updating.
• Audit for SiriKit. If you have an INExtension, plan the App Intents migration this year, not in year two of the deprecation window.
• Add App Intents for your top three to five user actions, and test them through AppIntentsTesting before you ship.
• Pick one Foundation Models feature that solves a real pain point, with a fallback for pre-A17 Pro devices.
• If you sell subscriptions, wire up retention messaging. Smallest change, clearest payback.
• Skip the rest until a real user need pulls you to it.

On balance iOS 27 is a friendlier cycle for small teams than the last two. A free cloud AI tier and a testable intents story are gifts, if you use them well.

Where people go wrong (and when to call a pro)

If you'd rather let someone who lives in this stack decide what's worth adopting, that's the work we do. Have a look at our services and tell us where your app is now.

Frequently asked questions