At WWDC 2026, Apple did something that got buried under the Siri AI headlines. Xcode 27 now ships with a set of agent skills that Apple wrote itself. These are not a community add-on. They are not a generic format you have to go track down. They come bundled in the toolchain, they capture Apple's internal guidance for modern Swift and SwiftUI, and you can export and read every one of them with a single command.
This matters more than the usual "AI coding assistant" update. For years, the default assumption was that the community would document new SwiftUI APIs for agents to consume. Apple is now the author. 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. That is a different quality of guidance than anything a third party can produce.
The seven skills
Xcode 27 ships with seven agent skills. When you export them, you get this exact list:
- swiftui-specialist: general guidance for writing idiomatic SwiftUI
- swiftui-whats-new-27: the newest SwiftUI APIs introduced this cycle
- 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
The swiftui-whats-new-27 one is the most valuable. Agents are least trained on the newest APIs, because training data lags behind release cycles. Apple shipping this skill in the box closes that gap directly.
Each skill is its own folder containing a SKILL.md and any supporting files. That is the open Agent Skills format, just authored by Apple.
How to pull them out
The skills live inside the toolchain. Apple gives you a command that routes through xcrun, which resolves to your active toolchain:
xcrun agent skills export --output-dir ~/Downloads/xcode-skills
Each skill lands in its own folder, ready to read or hand to a different agent. There is no hidden format and no Apple-specific container. They are plain Markdown files.
Two ways to use them
The obvious use is to let the agents in Xcode 27 consume 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. The agent reads only the short description at startup and pulls in the full instructions only when a task matches, so it stays cheap on context. That matters for long sessions where you are asking an agent to do a lot of work.
The second use is for you, directly. These files contain Apple's recommendations for modern Swift, SwiftUI, UIKit migration, testing, and security. You can read them as authoritative guidance. You can feed them into your own tooling and agents outside Xcode entirely. Exporting swiftui-whats-new-27 and reading it is one of the fastest ways to see what Apple considers current SwiftUI practice this cycle. No blog post, no release notes scavenger hunt, just the source.
Where this fits in Xcode 27
The skills are part of a larger agent story. Planning is now first class in Xcode 27. 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. That is a significant workflow change. You are no longer rubber-stamping an agent's final output. You are reviewing its approach before it touches your code.
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. There is a new Device Hub that unifies physical device and simulator management, which is where the device-interaction skill earns its place.
Here is what I think actually matters about all of this. Apple is treating agent guidance the same way it treats documentation and sample code. That means the guidance will track the actual APIs, because the people writing the APIs and the people writing the skills are in the same org. The community will still produce good content, but it will no longer be the only source an agent has.
Write your own skills
Apple's seven skills cover its frameworks. They cannot know your project's conventions. You will still want your own skills for that, and 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. Make it specific and front-load the situations that should trigger it. A generic description like "guidance for our app" will cause an agent to either load it constantly or never. Something like "Use this when a task involves modifying the payment flow, the checkout screen, or any code that touches the billing service" will get you reliable activation.
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 c-bounds-safety skill is a good example. It does not try to cover all of C programming. It covers bounds safety specifically, and its description tells the agent exactly when to load it.
The bigger picture
This fits a broader trend in automation that goes well beyond Apple. The first news story I read this week was about business automation becoming a necessity rather than a luxury, with workflow automation moving from basic rule-based triggers to advanced intelligent automation using AI and machine learning. Apple's agent skills are the developer-tool version of that same shift. The library of pre-built automation is expanding, but the people who get the most out of it are the ones who build their own layer on top.
There is a parallel in the tool guide landscape too. The noise of overlapping AI platforms and productivity apps keeps growing. The best digital toolkit is usually a focused stack, not a collection of dozens of overlapping subscriptions. That applies to agent skills as well. Seven Apple-authored skills plus a few of your own, scoped tightly, will get you further than fifty generic skill packs.
Takeaway
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 xcrun command is the most direct way to see what Apple actually shipped.
Run the export, read swiftui-whats-new-27 first, then write one skill for your own codebase. That is the fastest path to getting real value out of agent-driven development this cycle.