Using Xcode 27 Agent Skills in Claude, Codex, and Cursor

Apple added official "Agent Skills" support to the code agent with Xcode 27, and you can now export these skills to the ~/.agents/skills folder and use them in other agent IDEs like Claude Code, Codex, or Cursor. Using Xcode 27 Agent Skills starts with a single terminal command, but proceeding without knowing which skill works where — and what the directory convention means — leaves you with a setup that's half wasted. This guide walks through the export steps, which agents support the skills, and how they sit alongside the skills you write yourself.

💡 Pro Tip: Don't run the export command once and forget about it — as bleepingswift.com puts it, export is "a snapshot, not a live link," meaning that while Apple revises its skills as the SDKs change, the copies on your disk don't update themselves; re-running the command after every Xcode update keeps the list current.

Table of Contents

• What Agent Skills are, and what changed with Xcode 27
• The new `agent` CLI and its relationship to MCP
• Step-by-step export
• Which tools read the `~/.agents/` folder
• If skills don't show up in the IDE: refresh and restart checklist
• Using Apple's skills alongside the ones you write yourself
• Authoritative-source criteria and context cost when choosing a skill
• Practical payoff in an iOS workflow — where it actually makes a difference
• Troubleshooting: common situations after export
• FAQ
• What is Xcode 27 Agent Skills and how do you use it?
• How do I export Xcode skills to Claude Code or Cursor?
• What does the `xcrun agent skills export` command do?
• Where's it safe to get a skill from — why does the authoritative source matter?
• Do skills work the same way in every agent IDE?
• How often should I re-run the export command?
• Conclusion
• Sources

What Agent Skills are, and what changed with Xcode 27

Apple added official "Agent Skills" support to the IDE's code agent with Xcode 27, introduced at WWDC '26. Apple's own Xcode 27 release notes summarize it this way: "Xcode now ships with Apple-built specialists for targeted tasks, like localization, UIKit resizing and accessibility." The same document also notes that agents can now be extended with plugins: "Agents in Xcode can now be extended with plugins that contain skills, MCP servers, and ACP agent configurations. Skills are invokable as slash commands with completion support."

So Agent Skills are packaged instruction sets that plug into Xcode's agent as a plugin, discovered by name and description, and invoked via a slash command. This shares the same underlying structure as Anthropic's open Agent Skills standard — Apple isn't inventing its own skills, it's officially joining the existing open format as a producer. Xcode 27 also includes Swift 6.4 and the iOS/iPadOS/tvOS/watchOS/macOS/visionOS 27 SDKs, and requires macOS Tahoe 26.6 or later.

The new `agent` CLI and its relationship to MCP

Xcode 27 ships with a new CLI tool called agent. This CLI primarily focuses on Xcode's MCP (Model Context Protocol) support, but it now also carries the ability to export Agent Skills. Apple's release notes back up this MCP relationship with numerous items: build/test/debug tools were added to Xcode's MCP server, LLDB shipped with its own MCP server (lldb-mcp), and Xcode now offers Agent Client Protocol (ACP) support.

In short: the agent CLI covers skill export and MCP-related commands; Xcode's own agent infrastructure hosts the MCP server (build/debug/test tools), ACP support, and the plugin system (skills + MCP + ACP packaged together). One confirmation note worth flagging: Apple's official text includes the item "Fixed: Apple-authored agent skills may not be available to Codex" — proof Apple wants its own skills usable in Codex too, and treated the gap as a release bug.

Step-by-step export

The export command you run from Terminal.app copies the skills into ~/.agents/skills. Both forms of the command work: give the target directory directly as a positional argument, or use the --output-dir flag. With --output-dir, you must give an absolute path — the README of raven/xcode-agent-skills, the repo that tracks Apple's generated skill packages release by release, explains why: "xcrun agent skills export needs an absolute --output-dir, because relative paths resolve against Xcode's own working directory." A relative path resolves against Xcode's working directory, not the folder you're in, so the files can land somewhere you didn't expect.

1# Export skills from Xcode — target directory as positional argument
2xcrun agent skills export ~/.agents/skills
3 
4# Same job, flag form: this path must be ABSOLUTE, not relative
5xcrun agent skills export --output-dir /Users/<username>/.agents/skills

When you run the command you see output similar to this in the terminal — the block below is a reconstructed sample based on the actual output format and the names in the GA set:

1Exported 10 skills to /Users/<username>/.agents/skills
2  ✓ adopt-c-bounds-safety
3  ✓ app-intents-specialist
4  ✓ app-intents-whats-new-27
5  ✓ audit-xcode-security-settings
6  ✓ building-document-based-swiftui-applications
7  ✓ device-interaction
8  ✓ modernize-tests
9  ✓ swiftui-specialist
10  ✓ swiftui-whats-new-27
11  ✓ uikit-app-modernization

These ten skills are the complete "globally available" set returned by the xcrun agent skills export command, according to the Xcode 27.0 GA snapshot (build 27A266a) from the raven/xcode-agent-skills repo, which tracks each release. It's easy to mix up the count and the names, because secondary posts published during the WWDC '26 period (avanderlee.com and bleepingswift.com) show a list of seven skills — that list is a pre-GA beta snapshot, and two skills were renamed in beta 3: test-modernizer is now modernize-tests, and c-bounds-safety is now adopt-c-bounds-safety. The raven/xcode-agent-skills README ties this renaming directly to evidence: "the skill was renamed to adopt-c-bounds-safety in beta 3 (verified by re-running the export against a beta 3 install)." Three skills that don't appear at all in the beta list — app-intents-specialist, app-intents-whats-new-27, and building-document-based-swiftui-applications — appear in the GA export output.

Two practical warnings follow. First, overwriting an old export leaves stale folders on disk; the same README notes that --replace-existing only overwrites, it doesn't delete a skill dropped by the new build. If you went from beta to GA, manually clean up the c-bounds-safety folder, or the agent sees two skills on the same topic. Second, there are skill files inside Xcode besides these ten — the repo lists translation, translation-coordinator, and ios-dynamic-text as extracted from the app bundle and framework binary, and states they're not "globally available," meaning they never appear in the export at all. If you see these names elsewhere, they weren't obtained via the export command.

Which tools read the `~/.agents/` folder

As avanderlee.com puts it, "Many popular Agent IDEs support the ~/.agents/ folder to discover Agent Skills." This means the skills exported from Xcode aren't limited to Xcode alone — they're read by multiple clients through a shared directory convention.

On the Claude Code side, the official documentation (code.claude.com/docs/en/skills) confirms this: "Claude Code skills follow the Agent Skills open standard, which works across multiple AI tools." Claude Code's own native paths are separate: personal skills under ~/.claude/skills/<skill-name>/SKILL.md, project skills under .claude/skills/<skill-name>/SKILL.md (committable to the repo). The docs only define these two paths; ~/.agents/ doesn't appear there. On Codex and Cursor the path is defined verbatim in each tool's own docs: Codex lists $HOME/.agents/skills for user scope, $CWD/.agents/skills and $REPO_ROOT/.agents/skills for repo scope, and /etc/codex/skills for machine-wide scope; Cursor likewise counts ~/.agents/skills/ and .agents/skills/ among its auto-loaded locations. Apple's Codex-compatibility fix and avanderlee's Cursor screenshot ("Xcode's 27 Agent Skills are available inside the Cursor prompt field") confirm this in practice.

If your only target is Claude Code, you don't need the shared folder at all: export directly into Claude Code's personal skills directory. bleepingswift.com puts it plainly: "If you only care about Claude Code, you can skip the shared folder and drop the skills straight into its personal skills directory instead." Since each skill unpacks into its own subfolder with a SKILL.md inside, the result matches exactly what Claude Code expects for personal skills.

1# Export skills directly into Claude Code's personal skills directory
2xcrun agent skills export ~/.claude/skills

If you choose this path, the one extra step is refreshing the session: as the same source puts it, "Claude Code discovers skills at startup, so after exporting you'll want to restart it or run /clear." In other words, restart Claude Code after exporting, or run /clear in an open session; otherwise the new folders won't show up in that session.

If skills don't show up in the IDE: refresh and restart checklist

avanderlee's approach is simple: open the agent IDE, refresh the skill list if needed, and restart the IDE if it still doesn't show up. The practical checklist:

1. Verify the export command actually wrote to ~/.agents/skills — check the "Exported N skills to ..." line in the terminal.
2. Run the IDE's skill-list refresh command if one exists.
3. If refreshing isn't enough, close the IDE completely and reopen it.
4. If the skill still doesn't appear, check that the files actually contain a SKILL.md under ~/.agents/skills/<skill-name>/.

The export command isn't a one-time operation. bleepingswift.com writes that Apple revises these skills as SDKs change, particularly version-tied ones like swiftui-whats-new-27; since export is a snapshot, not a live link, disk copies don't refresh themselves. avanderlee expects new Xcode releases to bring new skills ("I expect future Xcode updates to ship new skills and updates to existing ones"). Practical rule: re-run the command after every Xcode update.

Using Apple's skills alongside the ones you write yourself

Claude Code's official documentation clarifies how skills from different sources coexist: personal (~/.claude/skills/), project (.claude/skills/, committable to the repo), and plugin skills load separately and can all be used together in the same session. The SKILL.md format is simple: you create a file with instructions, and Claude adds it to its toolset. So skills Apple exports from Xcode can sit side by side with your own project-specific skills without any format conflict — both follow the same open standard, but the directory convention differs (Apple's ~/.agents/ vs. Claude Code's native ~/.claude/skills/).

avanderlee also draws an important practical distinction: knowledge-focused skills (swiftui-specialist, swiftui-whats-new-27, and, under its GA name, modernize-tests) work everywhere because they only read and edit source files; but skills that need project settings or a running device (audit-xcode-security-settings, device-interaction) either fall back to manual project-file editing outside Xcode or become completely non-functional. In the source's own words: "the moment it needs your project configuration or a running device, you'll want to run it from inside Xcode."

1Sample directory layout: skills exported from Xcode sitting alongside your own project-specific skills
2 
3~/.agents/skills/swiftui-specialist/SKILL.md        (Apple export)
4~/.agents/skills/modernize-tests/SKILL.md           (Apple export)
5.claude/skills/project-lint-rules/SKILL.md          (your own, committed to repo)
6~/.claude/skills/personal-code-review/SKILL.md      (your own, personal)

Authoritative-source criteria and context cost when choosing a skill

The Agent Skills standard's official site (agentskills.io) explains its origin: "The Agent Skills format was originally developed by Anthropic, released as an open standard, and has been adopted by a growing number of agent products." Skills load in three stages — Discovery (only name/description enter the context), Activation (the full SKILL.md is read once the task matches), and Execution (instructions are followed, pulling in embedded code or source files as needed). This directly lowers context cost: many skills can be "kept on hand," but only the full text of the skill actually in use enters the token budget.

In terms of authoritative-source criteria, Apple is considered primary as the owner of its own IDE — but don't ignore AGENTS.md, a parallel standard. According to the Linux Foundation's December 9, 2025 announcement, AGENTS.md is one of the founding projects of the Agentic AI Foundation: "Its inaugural projects, AGENTS.md, goose and MCP, lay the groundwork for a shared ecosystem of tools, standards, and community-driven innovation." Its own site states it's used in more than 60,000 open-source projects. AGENTS.md and Agent Skills are different layers: AGENTS.md is a single markdown instruction file (static context), while Agent Skills is a modular folder structure discovered by name/description that packages instructions, code, and resources together. When choosing a skill, check whether the source is a primary producer (Apple, Anthropic) or a third-party compilation; third-party compilations can be useful, but if they don't clearly state which Xcode build they pulled the content from, you can't verify how current the list is.

Practical payoff in an iOS workflow — where it actually makes a difference

The concrete payoff points break down like this:

• swiftui-whats-new-27: covers new SwiftUI APIs in the 2027 OS releases, @State macro migration, drag-and-drop reordering, new toolbar APIs, and other source-incompatible changes. Since it only reads source files, it also works in Cursor.
• modernize-tests (previously named test-modernizer before beta 3): migrates existing XCTest suites to Swift Testing, converting setUp/tearDown to init/deinit. Another example that can work independently of the IDE.
• device-interaction: performs real verification via screenshots, UI hierarchy inspection, and synthesized taps, but depends on Xcode's own device and simulator tools, so it stays non-functional in Cursor or Codex.
• Apple's release notes also state agents can now launch a simulator, install an app, synthesize taps, capture screenshots, and access insights into crashes, hangs, or energy issues — Xcode-specific MCP tools, a separate layer from exported skills.

Bottom line: use knowledge-heavy skills (current SwiftUI API, test migration, adopt-c-bounds-safety) in whichever agent IDE you prefer; for real-device verification and project/build-setting inspection, go back to Xcode itself.

Troubleshooting: common situations after export

The order you follow matters when skills don't show up. First re-read the terminal output — if "Exported N skills to ..." actually printed, there's no file-system problem; the issue may be the IDE's folder-scanning timing. Counting folders under ~/.agents/skills with ls and matching that count against the terminal output should be your first verification step.

The second step depends on the agent IDE. In Claude Code, the native skill path (~/.claude/skills/ or .claude/skills/) and Xcode's export path (~/.agents/skills) are different directories; the shortest fix isn't moving files but exporting straight to the native path: xcrun agent skills export ~/.claude/skills, then restart or run /clear. In Cursor, avanderlee's screenshot shows skills appearing directly in the prompt field, so no extra copying seems necessary. On Codex, Apple's own compatibility fix in the release notes signals this integration is still maturing — if a skill doesn't show up, checking you're on Codex's latest version is a reasonable first step.

The third step is always the same: close the IDE completely and reopen it. Since skill discovery is generally a scan that happens once at IDE startup, a folder added mid-session may not show up without a restart.

FAQ

What is Xcode 27 Agent Skills and how do you use it?

Agent Skills are packaged instruction sets that plug into Xcode 27's agent as a plugin, discovered by name and description, and invoked via a slash command. Apple's release notes describe them as Apple-built specialists for targeted tasks like localization, UIKit resizing, and accessibility; export them with xcrun agent skills export ~/.agents/skills and use them in other agent IDEs too.

How do I export Xcode skills to Claude Code or Cursor?

Run the export command from Terminal.app, confirm the skills landed under ~/.agents/skills, then open the target agent IDE and refresh the skill list; if it still doesn't show up, restart the IDE. Targeting only Claude Code? Skip the shared folder and export straight into the personal skills directory with xcrun agent skills export ~/.claude/skills, then restart Claude Code or run /clear.

What does the `xcrun agent skills export` command do?

It copies Xcode's built-in, Apple-made skills into the target folder you specify, typically ~/.agents/skills; this lets other agent IDEs that read this shared directory (Claude Code, Codex, Cursor) list the skills in their own interfaces. You can give the target as a positional argument; if you use the --output-dir flag, you must give an absolute path, because relative paths resolve against Xcode's own working directory.

Where's it safe to get a skill from — why does the authoritative source matter?

The official export on Xcode 27.0 GA (27A266a) gives ten skills; some posts left over from the WWDC '26 period have an old beta list of seven skills circulating. Always get a skill by exporting it from your own Xcode installation, not from third-party compilations: the export command gives you the actual content of the installed build, while a compilation that doesn't state which build it was copied from leaves you unable to verify how current it is.

Do skills work the same way in every agent IDE?

No. Knowledge-focused skills that only read and edit source files (like current SwiftUI API, test migration) work in every agent IDE; skills that need project settings or a running device (audit-xcode-security-settings, device-interaction) stay non-functional outside Xcode.

How often should I re-run the export command?

There's no fixed interval, but export is a snapshot, not a live link: bleepingswift.com writes that Apple revises skills as the SDKs change, and avanderlee says they expect new skills to arrive with new Xcode releases. In practice, re-running the command after every Xcode update keeps the list current.

Conclusion

Xcode 27's Agent Skills support gives iOS developers real flexibility by exposing Apple's expert instruction sets through ~/.agents/skills, a shared directory that Claude Code, Codex, and Cursor can all read. Use knowledge-heavy skills in whichever agent you like — just remember skills that need a device or project settings still require Xcode.

If you want to dig deeper into the MCP and plugin ecosystem in Claude Code, check out Claude Code MCP: AI Plugin Ecosystem with Model Context Protocol. For a general comparison of IDE integrations, Claude Code IDE Entegrasyonu: VS Code, JetBrains ve Terminal (in Turkish) is useful. You can find everything else Xcode 27 changes for developers in iOS 27 ve Xcode 27: Geliştirici Gözünden Değişen Her Şey (in Turkish). If you want a pragmatic comparison across agent IDEs, GitHub Copilot vs Claude Code vs Cursor 2026: 6 Ay Kullanım Karşılaştırması (in Turkish) is a good read. If you want to expand on a concrete use case like the test-migration skill, take a look at AI Destekli Unit Test Üretimi: Claude Code + Cursor ile 2026 Workflow (in Turkish).

Sources

• Using Xcode 27's Agent Skills in Claude, Codex, and Cursor — export flow and agent-IDE screenshots (WWDC '26 beta snapshot: seven skills, old names)
• Using Xcode 27's Agent Skills in Claude Code — the direct ~/.claude/skills export path, initial skill discovery, and the /clear step
• raven/xcode-agent-skills — Xcode 27.0 GA (27A266a) export output, beta 3 renamings, and the --output-dir absolute-path rule
• Linux Foundation Announces the Formation of the Agentic AI Foundation — announcement that AGENTS.md is one of the AAIF founding projects (December 9, 2025)
• Xcode 27 Release Notes — Apple's official release notes, plugin/skill/MCP/ACP items
• Claude Code — Skills — Claude Code's own SKILL.md format and directory paths
• Cursor Docs — Agent Skills — Cursor's table of skill directories (including ~/.agents/skills/)
• Codex — Build skills — Codex's local skill locations ($HOME/.agents/skills, /etc/codex/skills)
• Agent Skills — official standard site — the format's origin and three-stage loading model
• AGENTS.md — the official site of the parallel open standard