WWDC 2026 - Xcode 27 Ships With Apple's Own Agent Skills: What They Are and How to Use Them

At WWDC 2026, Apple did something specific and easy to miss in the flood of Siri AI headlines: Xcode 27 now ships with a set of agent skills that Apple wrote itself. These are not a community add-on or a generic format you have to go find. They are bundled in the toolchain, they capture Apple's own guidance for modern Swift and SwiftUI, and you can export and read every one of them with a single command.

This article is about what Apple actually shipped here, the seven skills, where they live, how to get them out, and how they fit with the broader agent story in Xcode 27. If you want the high-level overview of agent-driven development in Xcode 27, that is a separate topic. Here the focus is narrow and concrete: Apple's own skills.

Why this matters

Coding agents are good at Swift in general but unreliable at the edges: brand-new APIs they have barely seen, recently deprecated patterns they keep reaching for, and platform-specific footguns. A skill is a focused bundle of guidance that fills exactly those gaps.

What changed at WWDC 2026 is that Apple is now the author. Instead of relying on the community to document, say, the newest SwiftUI APIs for an agent, Apple ships that guidance in the box. When an agent in Xcode 27 modernizes your UIKit code or audits your security settings, it can draw on instructions written by the people who built those frameworks.

The seven skills Apple bundles

Xcode 27 ships with seven agent skills. When you export them (covered below), you get this exact list:

• swiftui-specialist — general guidance for writing idiomatic SwiftUI.
• swiftui-whats-new-27 — the newest SwiftUI APIs introduced this cycle, the area agents are least trained on.
• uikit-app-modernization — moving older UIKit code toward current patterns.
• test-modernizer — updating test code to current testing practices.
• audit-xcode-security-settings — reviewing project settings against security best practices.
• c-bounds-safety — guidance around C bounds safety.
• device-interaction — working with devices and the simulator.

Each is its own folder containing a SKILL.md and any supporting files, exactly the open Agent Skills format, just authored by Apple.

Exporting Apple's skills

The skills live inside the toolchain, and Apple gives you a command to pull them all out. It routes through xcrun, which resolves to your active toolchain:

xcrun agent skills export --output-dir ~/Downloads/xcode-skills

Leave off --output-dir and it writes to the default location. When it finishes you will see the export confirmed, something like:

Exported 7 skills to /Users/you/Downloads/xcode-skills
  ✓ swiftui-specialist
  ✓ c-bounds-safety
  ✓ audit-xcode-security-settings
  ✓ test-modernizer
  ✓ uikit-app-modernization
  ✓ device-interaction
  ✓ swiftui-whats-new-27

Each skill lands in its own folder, ready to read or hand to an agent.

If the command is not found

The usual cause is that your command line tools still point at an older Xcode. Because xcrun resolves to whatever toolchain is selected, a stale selection means agent skills simply will not be available.

The fix: open Xcode 27, go to Settings, then the Locations tab, find the Command Line Tools dropdown, and set it to Xcode 27 (or your Xcode-beta entry if that is how your install is named). Then rerun the export.

Two ways to use them

These skills are built to be consumed by coding agents, but exporting them unlocks two distinct uses.

The first is the obvious one: let the agents in Xcode 27 use them. Because the skills are bundled, an agent can load swiftui-whats-new-27 when you ask it to adopt a new API, or audit-xcode-security-settings when you ask it to review your project's configuration. As with any skill, the agent reads only the short description at startup and pulls in the full instructions only when a task matches, so they stay cheap on context.

The second use is for you, directly. These are plain Markdown files containing Apple's recommendations for modern Swift, SwiftUI, UIKit migration, testing, and security. You can read them yourself as authoritative guidance, or feed them into your own tooling and agents outside Xcode. Exporting swiftui-whats-new-27 and reading it is one of the faster ways to see what Apple considers current SwiftUI practice this cycle.

How skills fit into the rest of Xcode 27's agent work

Apple's bundled skills are one piece of a broader push at WWDC 2026. A few other concrete items from the same release, since they affect how the skills get used in practice:

• Planning is now first class. Plans appear as editable Markdown artifacts next to the agent conversation, so you can review and adjust what an agent intends to do before it acts.
• Google Gemini joined the coding assistant, alongside the existing Anthropic and OpenAI integrations.
• The Xcode MCP server gained new tools that let agents debug by manipulating the active run state, reading and interacting with the debugger console, switching schemes and run destinations, and inspecting or modifying build settings, compiler flags, entitlements, and Info.plist keys.
• Agents can now localize apps, run tests, and fix crashes pulled from Organizer, and there is a new Device Hub that unifies physical device and simulator management, which is where the device-interaction skill earns its place.

On the game side, Apple also shipped open-source agent skills as part of Game Porting Toolkit 4, with Metal-specific guidance for bringing games to Apple platforms. That is a separate set from the seven bundled in Xcode itself, but it is the same pattern: Apple authoring skills for the areas where agents most need authoritative help.

Adding your own skills alongside Apple's

Apple's seven skills cover its frameworks. They cannot know your project's conventions, so you will still want your own skills for that. The format is identical: a folder with a SKILL.md whose YAML header carries a name and a description. The description is what the agent reads at startup to decide whether to activate the skill, so make it specific and front-load the situations that should trigger it.

A minimal example that enforces a project rule the model has no way of knowing:

---
name: "viewmodel-rules"
description: "Enforce this project's view model conventions: every view model is @MainActor and never imports SwiftUI. Use when creating, reviewing, or refactoring view models."
---

# View Model Rules

- Annotate every view model with `@MainActor`.
- Never `import SwiftUI` in a view model; it holds state and logic only.
- Expose state with `private(set)` and mutate it through methods.

If you find a view model that violates these rules, fix it in place and note what you changed.

Reading Apple's exported skills first is a good model for writing your own. They show how Apple scopes a skill to one job and how it phrases descriptions for reliable matching.

The short version

Export them and look:

xcrun agent skills export --output-dir ~/Downloads/xcode-skills

Seven skills, written by Apple, covering the newest SwiftUI APIs, UIKit modernization, test modernization, security auditing, C bounds safety, and device interaction. They power the agents in Xcode 27, and they double as authoritative reading you can use anywhere. For a developer adopting Xcode 27, that single command is the most direct way to see what Apple actually shipped.