SwiftUI App Intents Template for Apple Intelligence Apps

What an App Intents template actually contains

An App Intents template is a SwiftUI starter whose core actions are already exposed as intents: the things the app does, add an entry, start a session, look something up, defined with the App Intents framework so Siri, Shortcuts, Spotlight, and Apple Intelligence can invoke them without the app being open on screen. The template’s value is structural. It arrives with the three pieces wired together, the intent definitions, the entities they operate on, and an app shortcuts provider that names the phrases users can say, so a new feature means adding one intent, not inventing the architecture.

That structure is exactly what is missing from most generated apps. An agent prompted for “a habit tracker” builds screens; a habit tracker built on an intents spine also answers “log my workout” from Siri, surfaces habits in Spotlight, and hands Apple Intelligence real actions to compose. The screens still matter, they are where the intents land, but the spine is what makes the app feel native to the platform rather than ported to it.

How do App Intents connect an app to Apple Intelligence?

App Intents are the doorway: Apple Intelligence reaches into apps through the actions and entities they declare, so an app with no intents is invisible to it. When Siri composes a multi-step request, the steps it can take inside your app are precisely the intents you exposed, with assistant schemas marking common domains so the system understands an action’s shape, that this intent opens a photo, that one creates a note, without custom training.

The relationship runs in one direction worth internalizing: you do not integrate with Apple Intelligence, you describe your app to the system and the system integrates with you. Apple Intelligence launched with iOS 18.1 in October 2024 and requires recent hardware, an iPhone 15 Pro or newer, so the intents you write are also serving every older device through Shortcuts and Spotlight, which is what makes the work a platform investment rather than a feature bet. The same describe-your-actions thinking shows up when an AI agent reports status through Live Activities: the app declares structure, the system drives the surface.

One intent, many surfaces

The leverage of the framework is that one definition serves every surface. Write the intent once and it appears wherever the system can use it.

Surface	What the user does	What it demands of the intent
Siri and Apple Intelligence	Asks in natural language	Clear phrases, typed parameters, a spoken-friendly result
Shortcuts	Composes it into automations	Predictable inputs and outputs, no hidden UI dependency
Spotlight	Finds entities and acts on them	Entities with names, identifiers, and useful display data
Action button and controls	Triggers it with one press	Fast execution, sensible behavior with no parameters

Designing for the strictest column keeps the intent honest everywhere: if the action runs headless in a Shortcut with typed inputs and a typed result, it will behave under Siri and the Action button too. The interface side of the template, the screens those intents open and the states they update, is where a free VP0 design earns its place: a real SwiftUI screen with a machine-readable source page that an agent like Claude Code or Cursor reads from a pasted link and extends, while the intent layer stays a thin, typed contract over the same actions. A worked example of the assistant-side wiring lives in the Apple Intelligence API example.

How do you structure intents so an agent builds them right?

Keep each intent a thin door into logic the app already owns. The intent declares a title, parameters, and a result, then calls the same function your button calls; the moment business logic moves into the intent body, you have two implementations to keep honest. This is also the structure agents handle best, because the intent files become boilerplate-shaped: small, declarative, and patterned after one worked example you give them.

Entities deserve the same discipline. An entity is the noun your intents share, the habit, the document, the session, with an identifier and display representation, and it should wrap your existing model type rather than replace it. Define one entity well and the agent can repeat the pattern; let the agent invent entities ad hoc and every intent grows its own incompatible nouns. The practical prompt order is: one example intent and one example entity written carefully by hand or taken from a template, then “follow this pattern” for the rest. The Swift project, with roughly 70,031 GitHub stars, moves fast enough that agents trained on older code will offer outdated signatures, so the in-repo example also acts as the corrective reference.

What Apple Intelligence does and does not promise

The honest version: App Intents are guaranteed leverage today; the deepest Apple Intelligence behaviors arrive on Apple’s schedule, not yours. Shortcuts, Spotlight, the Action button, and classic Siri phrases work now, on shipping iOS, for any app that declares intents. The richer composition, Siri taking multi-step actions across apps with onscreen awareness, has rolled out in stages, with assistant schemas covering defined domains first.

Plan for that honestly rather than optimistically. Build the intents spine because it pays on every surface immediately, and treat the deeper Siri behaviors as upside that arrives without extra work when the platform reaches your domain. What you should not do is market an app around capabilities the system has not shipped to your users’ devices, or gate core features behind hardware most of your audience lacks, since Apple Intelligence requires an iPhone 15 Pro or newer while your app likely supports years of older phones. The intents are the durable asset; the assistant features are compounding interest on them. The older-but-still-shipping pattern, donating shortcut phrases from a React Native app, is covered in the Siri Shortcuts integration guide.

Common mistakes when vibe coding App Intents

The recurring failure is intents as an afterthought: the agent builds the whole app around screens, then bolts on two intents that open those screens. Opening a screen is the weakest thing an intent can do. The strong version performs the action and returns a typed result, so Siri can speak it, Shortcuts can chain it, and the user gets the outcome without watching navigation happen.

Watch for three more. Agents write intents that silently depend on app state, a selected project, a logged-in session, which run fine in the demo and fail headless in a Shortcut; every dependency must be a parameter or a clear error. They duplicate logic into intent bodies, which drifts from the buttons within weeks. And they skip phrase quality, shipping app shortcut phrases nobody would say aloud; phrases should be short, natural, and tested by speaking them, because Siri matching is the front door. The fix for all three is the same: a template whose example intent demonstrates the right shape, and prompts that point at it. The system-level overlay treatment around Siri experiences is its own topic, covered in the Siri overlay clone.

Key takeaways: an App Intents template

• Intents are the spine, screens are the landing. Define actions once; Siri, Shortcuts, Spotlight, and the Action button all reuse them.
• Apple Intelligence reaches apps through intents. No intents, no presence; schemas tell the system what your actions mean.
• Thin doors, shared nouns. Intents call existing logic; entities wrap existing models.
• Build for headless first. Typed parameters, typed results, no hidden state.
• Start screens from a free VP0 design. The agent extends the interface from its source page while the intent layer stays a typed contract.

The practical starting point

Start from a template that pairs one carefully written intent and entity with real screens, then let the agent repeat the pattern action by action. Take the screens from a free VP0 design, extended from its source page by Claude Code or Cursor, and keep the intent layer hand-shaped: one example each of an intent, an entity, and an app shortcut phrase, treated as the canonical pattern the agent must follow. Ship the spine even if Apple Intelligence has not reached your domain yet, because Shortcuts, Spotlight, and the Action button pay for it today on every supported device. The one situation to deprioritize intents is an app with genuinely no actions worth invoking externally, a pure content viewer, where the platform surfaces have little to grab.

Frequently asked questions

How do I build a SwiftUI App Intents template for Apple Intelligence? Structure the app around a small set of typed actions: each intent declares a title, parameters, and a result, and calls the same logic your buttons use. Add entities that wrap your model types with identifiers and display names, and an app shortcuts provider with natural spoken phrases. Write one exemplary intent and entity by hand, then have your agent repeat the pattern per action. Take the screens from a free VP0 design extended from its source page, and keep the intent layer thin and headless-safe.

Do App Intents require Apple Intelligence? No. App Intents shipped with iOS 16 and serve Shortcuts, Spotlight, classic Siri, and the Action button on hardware that will never run Apple Intelligence. Apple Intelligence is an additional consumer of the same declarations: when it reaches your users and your domain, the actions you already declared become material Siri can compose. That is the reason to build the spine now, since the work pays immediately on shipping surfaces and appreciates as the assistant layer expands.

Which devices run Apple Intelligence? It launched with iOS 18.1 in October 2024 and requires recent hardware, an iPhone 15 Pro or newer iPhone. That cutoff is exactly why intents-first design matters: most apps support several years of older devices, and those users still get the full value of the same intents through Shortcuts, Spotlight, and classic Siri. Treat the assistant features as an upgrade tier the platform delivers, not a baseline you can assume across your audience.

Is there a free template with App Intents wired in? The combination that works is a free VP0 screen design plus a hand-shaped intents example. VP0 provides the interface side at no cost, real iOS designs with a machine-readable source page an agent reads from a pasted link, and the intents side wants one canonical intent, entity, and phrase written carefully, because agents repeat patterns far more reliably than they invent architecture. Together that is a template: shaped screens, a typed action spine, and a pattern the agent extends per feature.

What should an App Intent return? A typed result that stands alone without the app’s UI: the entry that was created, the value that was looked up, a clear error when a required parameter is missing. Returning real results is what lets Shortcuts chain your action into automations and lets Siri speak an answer instead of opening a screen. Intents that merely navigate are the weakest form, so reserve them for cases where showing a screen genuinely is the action the user asked for.