Apple Xcode 27 and Siri AI Turn App Intents Into Sprint Scope

WWDC26 wrapped this week, and Apple's developer announcements are a useful planning signal for any team building AI-enabled product workflows.

Apple introduced Siri AI, expanded App Intents, new Foundation Models capabilities, Core AI for on-device models, and Xcode 27 agentic coding features. The headline sounds like developer productivity. The sprint planning reality is broader: apps are becoming easier for agents and system intelligence to understand, search, and act inside.

That changes how teams should estimate Apple platform work.

When Siri can understand app entities, use on-screen context, move content between apps, and trigger app actions through natural language, a backlog item is no longer just "add Siri support." It includes data modeling, permissions, confirmation states, App Intents testing, privacy boundaries, fallback behavior, and product review.

Planning poker needs to catch those assumptions before the sprint starts.

App Intents are now product contracts

Apple's WWDC26 Apple Intelligence guide says App Intents are how apps connect to Apple Intelligence and Siri AI. App entities make app content discoverable, schemas help Siri understand what kind of content or action it is dealing with, and intent schemas let people take action naturally.

That sounds technical, but it is really a product contract.

If a task-management app exposes tasks to Siri, the team is deciding which tasks are searchable, which actions are available, and what "complete this task" means when triggered outside the app's usual screen. If a messaging app exposes a send action, the team is deciding how recipients are resolved, what confirmation is needed, and how mistakes are prevented.

Before voting, ask:

• Which app entities are being exposed?
• Which properties can Siri search or reason over?
• Which actions can be triggered from Siri, Spotlight, Shortcuts, widgets, or another app?
• Which actions are read-only, draft-only, or immediately mutating?
• What confirmation is required before user data is sent, deleted, moved, or shared?
• What happens if Siri resolves the wrong entity?
• How will the user inspect or undo the action?
• How will the team test the integration outside the happy path?

If those answers are missing, the estimate should go up or the story should be split.

Cross-app workflows make small stories bigger

Apple's "Build intelligent Siri experiences with App Schemas" session shows why App Intents work can expand quickly. Siri can understand app entities, take actions through intents, use on-screen context, and support workflows that move content across apps.

That is powerful. It also multiplies assumptions.

A story that starts as "let users ask Siri to send this report" might include:

• Modeling the report as an app entity.
• Indexing the right metadata.
• Resolving contacts or destinations.
• Transferring content between apps.
• Handling missing permissions.
• Showing a preview before sending.
• Logging the action.
• Supporting cancellation or correction.
• Testing Siri, Shortcuts, Spotlight, and app UI paths.

The visible demo may take seconds. The safe product behavior takes planning.

Planning poker is useful because different people will notice different parts of that hidden scope. A product manager may see a convenience feature. An engineer may see entity resolution and App Intents testing. A designer may see confirmation UX. A privacy reviewer may see data exposure across apps. A support lead may see "Siri sent the wrong thing" tickets.

That spread is the point of the conversation.

Xcode 27 makes agentic coding a planning topic

Apple also announced Xcode 27 agentic coding features. Xcode conversations can include interactive planning, multiturn Q&A, rendered Markdown, code changes, and previews. Apple says agents can validate their own work for longer by writing and running tests, trying ideas in Playgrounds, checking previews, and interacting with simulators in Device Hub.

That can speed up development, but it does not remove estimation.

If an agent can create a patch and run tests, the team still needs to estimate:

• The quality of the existing tests.
• Review time for generated code.
• Visual review across devices.
• Accessibility checks.
• Localization impact.
• Performance impact.
• App Store review risk.
• Security and privacy review.
• Whether the agent's proposed plan matches the product intent.

The story is not "Xcode agent does it." The story is "the team accepts, validates, and ships the result."

A low vote and high vote may both be correct

Imagine a story that says: "Expose project status updates to Siri AI."

One person votes 3 because App Intents schemas exist and Xcode 27 can help generate the integration. Another votes 13 because the project status includes customer names, private notes, billing dates, internal blockers, and cross-workspace permissions.

Both voters may be seeing real work.

The low voter is assuming:

• Read-only access.
• Simple entity mapping.
• No sensitive fields exposed.
• Existing permissions apply.
• Siri only opens the app or drafts a response.
• The agent-generated code is reviewed normally.

The high voter is assuming:

• Personal context may surface private content.
• Entity resolution can choose the wrong project.
• Users may trigger actions outside the app UI.
• Confirmation and undo states need design.
• App Intents testing needs new coverage.
• Admin settings may need to limit what Siri can access.

Do not average those votes immediately. Ask which boundary each person assumed.

The right estimate follows the boundary, not the excitement around the framework.

Split Apple Intelligence stories before sprint commitment

AI platform work becomes hard when teams combine model integration, app actions, system search, privacy, UX, and agentic coding into one ticket.

A healthier backlog separates the work:

• Model the app entities.
• Decide which fields can be indexed or searched.
• Add read-only Siri discovery.
• Add one safe action behind confirmation.
• Add App Intents testing.
• Add Shortcuts and Spotlight validation.
• Add analytics or audit notes.
• Add admin or privacy controls.
• Expand allowed actions only after evidence.

Each ticket becomes easier to estimate because the team can discuss one risk boundary at a time.

This also makes sprint reviews better. The team can show Siri finding content before it allows Siri to change content. It can show Xcode agent output before treating it as production-ready. It can learn from each increment instead of betting the sprint on one large AI integration.

Update definition of done for App Intents

Apple's new tooling makes it easier to build intelligent experiences, but teams still need a clear definition of done.

For App Intents and Siri AI work, useful acceptance notes might include:

• "Entities expose only approved fields."
• "Mutating actions require user confirmation."
• "Siri, Shortcuts, Spotlight, and in-app paths tested."
• "AppIntentsTesting coverage added for entity resolution."
• "Sensitive fields excluded from semantic indexing."
• "Undo or correction path documented."
• "Generated Xcode agent changes reviewed by owner."
• "Privacy language updated if data is available outside the app screen."

These notes help future planning. They also reduce the chance that AI integration work is mistaken for a quick developer-only change.

Product teams need to estimate trust, not just code

The most important planning shift is trust.

When a user asks Siri to act on app content, the product has to earn trust in several moments. Did Siri understand the right object? Is the action safe? Is the user in control? Can the user see what happened? Can the team explain why it happened?

Those questions belong in sprint planning, not only in QA.

Before committing Apple Intelligence work, ask:

• What user outcome are we improving?
• What system intelligence can infer?
• What action can be taken?
• What data leaves the current screen?
• What must be confirmed?
• What must be reversible?
• What can be tested automatically?
• What needs human product review?

If the answers are unclear, the next step is refinement.

The takeaway for June 13

Apple's WWDC26 announcements show that agentic workflows are moving deeper into the operating system, the IDE, and the app layer. Siri AI, App Intents, Foundation Models, Core AI, and Xcode 27 all point in the same direction: apps will be easier for AI systems to understand and act through.

That is good news for users and developers. It is also a planning challenge.

Planning poker gives teams a simple way to keep the commitment honest. Vote privately. Reveal the spread. Ask what each person assumed about entities, actions, permissions, confirmation, testing, and review. Record those assumptions before the story enters the sprint.

AI platform features may make implementation faster, but the sprint still needs to estimate the work that makes those features safe, understandable, and ready to ship.