Xcode 27 Ships Agent Skills You Can Export Anywhere

Apple shipped two of its own SwiftUI agent skills inside the Xcode 27 toolchain, and one command moves them out: xcrun agent skills export.¹ The skills carry Apple’s internal SwiftUI knowledge, the Coding Assistant in Xcode 27 reaches for them when relevant, and the exporter writes them to markdown files you can import into your workflows¹ — which is exactly what Claude Code, Codex, and Cursor consume. The platform vendor now maintains the domain expertise; your agent, whichever one you run, consumes it.

That pattern showed up twice at WWDC 2026. Game Porting Toolkit 4 distributes Apple’s Metal and MetalFX porting expertise as a plugin from the Game Porting Toolkit marketplace on GitHub (installed in Claude Code via /plugin marketplace add apple/game-porting-toolkit), covered in Game Porting Toolkit 4: Agentic Game Ports on Mac. The SwiftUI skills take the same idea and make it portable across agents with a single export step. Two surfaces, one strategy: first-party skills replace scraped, stale documentation with curated best practices and what is genuinely new in this release.

TL;DR

• Xcode 27 includes two SwiftUI agent skills: the SwiftUI Specialist Skill (best practices) and the What’s New In SwiftUI Skill (adopting the 2027-release APIs), both accessible in the Coding Assistant in Xcode 27.¹
• xcrun agent skills export writes the skills to markdown files you can import into your workflows¹, which is exactly what Claude Code, Codex, or Cursor consume, so the same Apple knowledge powers whichever agent you run.
• A WWDC lab panel described the skills as encoding “all of our internal knowledge, all the best practices,” and said models showed “significantly better reasoning” when invoking them; the SwiftUI performance guidance (extract subviews, keep view bodies small) is itself baked into the skills.²
• The companion move is Game Porting Toolkit 4, which ships porting skills as a plugin from the GPTK marketplace on GitHub (installed in Claude Code via /plugin marketplace add apple/game-porting-toolkit). Apple is generalizing first-party skills as a distribution channel.

What the two skills are

Steven and Julia from the UI Frameworks team closed “What’s new in SwiftUI” with the announcement, after a full session on the 2027-release APIs.¹

The agent-skills segment of “What’s new in SwiftUI,” starting around 26:50.

Apple shipped two skills, and each targets a distinct failure mode that general-purpose models hit with SwiftUI. The SwiftUI Specialist Skill “can help you follow SwiftUI best practices in your apps.”¹ The What’s New In SwiftUI Skill “can guide you through adopting new APIs from the 2027 releases.”¹ The split matters: a model trained before this year’s APIs existed has no way to know about the new toolbar visibilityPriority modifier or the lazy @State macro behavior, and it picks up bad habits where its training data carried them. One skill encodes the durable craft; the other encodes the deltas the model could not have seen.

Inside Xcode, you do not invoke them by name. “Both of these skills can be accessed in the Coding Assistant in Xcode 27,” and the agent loads them when they are relevant to what you are working on.¹ You get the expertise without managing it.

Export to any agent

The portability is the headline. Apple’s words, near the 27:12 mark of the session: “to use these skills with other tools, you can export them with the ‘xcrun agent skills export’ command. This will create markdown files you can import in your workflows.”¹

xcrun agent skills export

One command, markdown output, no Xcode lock-in. If you drive your iOS work from Claude Code in a terminal, or Codex, or Cursor, the same Apple-authored SwiftUI knowledge drops into your existing setup. The exported files are plain markdown, which means they slot into whatever skill or context mechanism your agent already uses. A model running outside Xcode does not get the skills baked in, so the export step is what closes that gap.²

The design choice underneath is worth naming. Apple could have kept the skills proprietary to the Coding Assistant and used them as a reason to keep you inside Xcode. Instead the company shipped an exporter, which treats the knowledge as the product and the editor as one of several consumers. For developers who already run an agent of their own, that is the difference between adopting Apple’s recommendation and rewriting it from scratch.

Why first-party skills beat scraped docs

A WWDC lab panel from the UI Frameworks team spent a stretch on exactly this, prompted by a developer who had hit recurring Swift errors while vibe-coding with a general model.²

The skills discussion in the SwiftUI for Beginners Group Lab, around 37:00. No official captions exist for this lab; quotes are paraphrased from a local transcription.

A panelist named the root problem first: large language models “sometimes producing a little bit incorrect results when it comes to SwiftUI and some of our newer APIs that maybe the model wasn’t really trained on yet.”² The fix, in the panel’s framing, is that Apple “fed [the skills] with all of our internal knowledge, all the best practices we have for data flow in your apps, for the new APIs that were introduced.”² That is the structural advantage over scraping the public docs site: the skills carry guidance Apple’s own engineers apply, organized for an agent to act on, refreshed alongside the framework.

The panel also reported a measurable effect. Models “got significantly better reasoning when they were invoking those skills,” and the panelists were “sure that the skills should provide greater comfort when using those models.”² The encoded guidance is concrete, not abstract. The performance advice that ran through the entire lab, extract repeated view chunks into custom views rather than computed properties, keep view bodies small, avoid heavy work like number-formatter allocation inside body, read only the environment values a view actually uses, is itself in the skills. As one panelist put it while answering a performance question, “all of this guidance is in the skills. So, if you’re using a model to generate that code, it should automatically put like refactor of views into smaller views.”²

One precise caveat, because the lab was precise about it. Inside Xcode the skills are available in the coding agent, so the agent “should kind of refer to the appropriate skill when needed based on the context,” and the lab moderator asked specifically whether anything needs enabling. The answer was that the skills “should be there” by default in the Coding Assistant.² The skills are available to the agent, and the agent invokes the appropriate one when it is relevant. That is the accurate claim, and it is the one to make.

The broader pattern

Apple is treating curated agent skills as a distribution channel for first-party expertise, and the SwiftUI skills are one of two examples from this WWDC.

The other is Game Porting Toolkit 4. Apple ships its Metal 4, MetalFX, shader-compilation, and GPU-debugging knowledge as expert skills plus a milestone-based workflow, distributed as a plugin from the Game Porting Toolkit marketplace on GitHub (installed in Claude Code via /plugin marketplace add apple/game-porting-toolkit), as covered in Game Porting Toolkit 4: Agentic Game Ports on Mac. The mechanics differ, a GitHub plugin marketplace for porting versus a toolchain exporter for SwiftUI, but the strategy is identical: Apple authors and maintains the domain knowledge, packages it as agent skills, and lets your agent of choice consume it.

The implication for how you build iOS apps with an agent is direct. The question shifts from “which model knows SwiftUI best” to “is my agent loading Apple’s current SwiftUI skill.” A weaker general model running the first-party skill can outperform a stronger model improvising from stale training data, because the skill carries the APIs that shipped this year and the practices Apple’s engineers actually follow. The export command is what makes that available outside Xcode.

The skills sit alongside the rest of Apple’s agentic story this year: the IDE going agentic in Xcode 27 Went Agentic, and the full SwiftUI 2027-release API surface in What’s New in SwiftUI for iOS 27. The skills are the connective tissue, the mechanism that carries Apple’s framework expertise into whatever agent does the work.

Key Takeaways

For iOS developers using an external agent (Claude Code, Codex, Cursor): - Run xcrun agent skills export to pull the SwiftUI Specialist and What’s New In SwiftUI skills out of the Xcode 27 toolchain as markdown, then import them into your agent’s skill or context mechanism.¹ - Prefer the first-party skill over scraped documentation for any post-2027-release API; the model’s training data predates visibilityPriority, the lazy @State macro, and the new Document API.¹

For developers staying in Xcode: - The two skills are already accessible in the Coding Assistant and load when relevant to your code; no setup beyond Xcode 27.² - File feedback through Feedback Assistant when the skills miss, because the panel was explicit that developer feedback drives how Apple evolves them.²

For teams choosing a coding agent: - Evaluate agents on skill ingestion alongside raw model quality. An agent that loads Apple’s current SwiftUI skill produces more correct, more idiomatic code than a stronger model improvising from old docs.² - Watch the pattern spread. Apple already distributes game-porting skills as a Claude Code plugin; expect more first-party skill packs as the channel matures.

FAQ

What are the two SwiftUI agent skills in Xcode 27?

The SwiftUI Specialist Skill, which helps an agent follow SwiftUI best practices, and the What’s New In SwiftUI Skill, which guides adoption of the new 2027-release APIs. Both are accessible in the Coding Assistant in Xcode 27.¹

How do I use Apple’s SwiftUI skills with Claude Code or another agent?

Run xcrun agent skills export from a terminal. The command writes the skills to markdown files that you import into your workflows¹, which is exactly what Claude Code, Codex, Cursor, or any other tool can ingest, so each can use Apple’s SwiftUI knowledge. A model running outside Xcode does not get the skills automatically, so the export step is required.

Do the skills load automatically inside Xcode?

Inside the Xcode 27 Coding Assistant the skills are accessible by default, and the agent invokes the appropriate one based on the context of what you are working on. You do not call them by name.²

Why use a first-party skill instead of letting the model rely on its training?

General models produce incorrect SwiftUI when they hit APIs that postdate their training or carry habits from stale documentation. Apple’s skills encode its internal best practices and the current APIs, and a WWDC lab panel reported that models showed significantly better reasoning when invoking them.²

Is Apple shipping agent skills for anything besides SwiftUI?

Yes. Game Porting Toolkit 4 distributes Apple’s Metal and MetalFX porting expertise as a plugin from the Game Porting Toolkit marketplace on GitHub (installed in Claude Code via /plugin marketplace add apple/game-porting-toolkit). The SwiftUI skills and the porting skills are two instances of the same strategy: Apple maintains the domain knowledge and your agent consumes it.

Xcode 27 Went Agentic covers the IDE side of Apple’s agentic shift, What’s New in SwiftUI for iOS 27 details the 2027-release APIs the What’s New skill teaches, and Game Porting Toolkit 4: Agentic Game Ports on Mac is the sibling first-party-skills story on the gaming side. The full series hub is the Apple Ecosystem Series.

References