ios-app-intents

Savant verdict: Analyzed

Scanned or evaluated by Savant; not yet both passing.

Live evaluation

2 pass · 1 investigate · 5 fail across 8 cases. Jev accepted 8 of 16 LLM-drafted cases. Drafted and run by nvidia/nemotron-3-super-120b-a12b, validated and scored by jev-latest.

• I want to expose a 'Compose new message' action from my messaging app to Siri and Shortcuts so users can start composing without opening the app first. The app already has a MessageComposer service that handles draft creation.positive case · pass
• In my note-taking app, users often jump to a specific project from Spotlight or Siri. I need to expose project navigation as an App Intent that opens the app to the selected project's detail view.positive case · pass
• For my file management app, I want to let users favorite a document directly from a Shortcut or Siri suggestion without opening the app. The app has a DocumentService with a toggleFavorite method.positive case · investigate
• I want to add an App Intent that lets users search for a note by free-form text in Siri, like 'Find notes about vacation'.edge case · fail
• Generate the full SwiftUI view hierarchy for a settings screen that appears when the user says 'Open settings' to Siri.negative case · fail
• Write a Core Data migration script to update my app's model for iOS 18 compatibility with App Intents.negative case · fail
• I want to expose an App Intent for viewing user analytics dashboards in my business intelligence app. The dashboards are highly configurable with multiple filter combinations, date ranges, and comparison modes. Users should be able to open specific dashboard views from Siri and Spotlight.edge case · fail
• For my recipe app, I want to create App Intents that let users add ingredients to a shopping list from anywhere in the system. Each ingredient has many attributes like brand, organic status, and preparation notes, and users frequently need to specify quantities and units.edge case · fail

Safety (NVIDIA SkillSpector)

0 patterns found

Structure

• No license declaredConfirm you may reuse this skill before importing it into your repository.

SKILL.md

---
name: ios-app-intents
description: Design App Intents, app entities, and App Shortcuts for iOS system surfaces. Use when exposing app actions or content to Shortcuts, Siri, Spotlight, widgets, or controls.
---

# iOS App Intents

## Overview
Expose the smallest useful action and entity surface to the system. Start with the verbs and objects people would actually want outside the app, then implement a narrow App Intents layer that can deep-link or hand off cleanly into the main app when needed.

Read these references as needed:

- `references/first-pass-checklist.md` for choosing the first intent and entity surface
- `references/example-patterns.md` for concrete example shapes to copy and adapt
- `references/code-templates.md` for generalized App Intents code templates
- `references/system-surfaces.md` for how to think about Shortcuts, Siri, Spotlight, widgets, and other system entry points

## Core workflow

### 1) Start with actions, not screens
- Identify the 1-3 highest-value actions that should work outside the app UI.
- Prefer verbs like compose, open, find, filter, continue, inspect, or start.
- Do not mirror the entire app navigation tree as intents.

### 2) Define a small entity surface
- Add `AppEntity` types only for the objects the system needs to understand or route.
- Keep the entity shape narrower than the app's persistence model.
- Add `EntityQuery` or other query types only where disambiguation or suggestions are genuinely useful.

### 3) Decide whether the action completes in place or opens the app
- Use non-opening intents for actions that can complete directly from the system surface.
- Use `openAppWhenRun` or open-style intents when the user should land in a specific in-app workflow.
- When the app must react inside the main scene, add one clear runtime handoff path instead of scattering ad hoc routing logic.
- If the action can work in both modes, consider shipping both an inline version and an open-app version rather than forcing one compromise.

### 4) Make the actions discoverable
- Add `AppShortcutsProvider` entries for the first set of high-value intents.
- Choose titles, phrases, and symbols that make sense in Shortcuts, Siri, and Spotlight.
- Keep shortcut phrases direct and task-oriented.
- Reuse the same action model for widgets and controls when a widget configuration or intent-driven control already needs the same parameters.

### 5) Validate the runtime handoff
- Build the app and confirm the intents target compiles cleanly.
- Verify the app opens or routes to the expected place when an intent runs.
- Summarize which actions are now exposed, which entities back them, and how the app handles invocation.

## Strong defaults

- Prefer a dedicated intents target or module for the system-facing layer.
- Keep intent types thin; business logic should stay in app services or domain models.
- Keep app entities small and display-friendly.
- Use `AppEnum` for fixed app choices such as tabs, modes, or visibility levels before reaching for a full entity type.
- Prefer one predictable app-intent routing surface in the main app scene or root router.
- Treat App Intents as system integration infrastructure, not only as a Shortcuts feature.

## Anti-patterns

- Exposing every screen or tab as its own intent without a real user value.
- Mirroring the entire model graph as `AppEntity` types.
- Hiding runtime handoff in global side effects with no clear app entry path.
- Adding App Shortcuts with vague phrases or generic titles.
- Treating the first App Intents pass as a broad taxonomy project instead of a small useful release.

## Notes

- Apple documentation to use as primary references:
  - `https://developer.apple.com/documentation/appintents/making-actions-and-content-discoverable-and-widely-available`
  - `https://developer.apple.com/documentation/appintents/creating-your-first-app-intent`
  - `https://developer.apple.com/documentation/appintents/adopting-app-intents-to-support-system-experiences`
- In addition to the links above, use web search to consult current Apple Developer documentation when App Intents APIs or platform behavior may have changed.
- A good first pass often includes one open-app intent, one action intent, one or two entity types, and a small `AppShortcutsProvider`.
- Good example families to cover are:
  - open a destination or editor in the app
  - perform a lightweight action inline without opening the app
  - choose from a fixed enum such as a tab or mode
  - resolve one or more entities through `EntityQuery`
  - power widget configuration or controls from the same entity surface