← Back to blog
XcodeiOS 27AISwiftUIProductivity

Xcode 27 Agent Skills in your favorite editor: one command puts Apple's 7 skills in Claude, Cursor, or Codex

S
Slekens
Sep 19, 2026 · 7 min read

This is the first of three posts covering what shipped for developers between September 14 and 19 — five days of news that didn’t fit in the launch post. The next covers Device Hub and the third the six new APIs for iPhone Duo.

Xcode 27 didn’t just add agentic coding with Claude, Gemini, and GPT inside the editor — Apple shipped 7 documented agent skills you can export with a single command and drop into Claude Desktop, Cursor, Codex, or any editor that reads ~/.agents/skills/ (SwiftLee — Using Xcode 27’s Agent Skills, Livsy Code).

The command that changes everything

xcrun agent skills export ~/.agents/skills

One command. That directory is the convention popular agent IDEs already recognize — they look there at startup. After exporting, relaunch Claude Desktop / Cursor / Codex and all 7 show up.

The 7 skills, one by one

These are skills written by Apple, using the same conventions as community skills — but with the authority of “this is how Apple expects you to do things.” They range from daily SwiftUI to bigger migrations of UIKit or XCTest.

1. swiftui-specialist — the daily one

Covers day-to-day SwiftUI: view structure, data flow, modifiers, ForEach, localization, and soft deprecations. This is the one you call when you’re refactoring a view and want to check you’re following the pattern Apple recommends.

When to use: review of existing SwiftUI code, choosing between two ways to solve the same problem, understanding what’s idiomatic in 2026.

2. swiftui-whats-new-27 — for the SDK 27 migration

Focused on going from iOS 26 to iOS 27: the @State macro, toolbar changes, reorderable containers, swipe actions outside List, AsyncImage caching, document APIs, and this year’s concrete deprecations.

When to use: updating your app to compile against iOS 27 SDK, the compiler throws deprecation warnings — hand the code over and it tells you what to do with each one.

3. uikit-app-modernization — for apps still on old patterns

Replaces legacy APIs like UIScreen.main and interfaceOrientation to support multi-window environments. Covers Swift and Objective-C (yes, Apple still considers Objective-C exists).

When to use: UIKit app with years on it, you want to move to iOS 27 without breaking multi-window, and you don’t know where to start. Give it the file, it hands back a modernized version with an explanation for each change.

4. test-modernizer — XCTest to Swift Testing without the pain

Incremental migration from XCTest to Swift Testing. Converts setUp/tearDown to init/deinit, translates XCTAssert to #expect, and introduces traits and parameterized tests where they make sense.

When to use: your test suite is still XCTest and you want to start migrating. We know XCTest isn’t deprecated (covered in the iOS 27 post), but migrating the tests you touch often is the pattern Apple recommends — and this skill does exactly that, one file at a time.

5. c-bounds-safety — for modern C code

Adopting C’s -fbounds-safety extension, which prevents out-of-bounds memory access. Niche but real: if your app uses third-party C libraries or has custom wrappers, this is what you want to run against that code.

When to use: integrating C SDKs, writing Objective-C runtime tricks, or porting old code.

6. audit-xcode-security-settings — the checkpoint we never did

Audits your Xcode project and progressively enables Enhanced Security, compiler warnings, and static analyzer checkers. Doesn’t do it all at once (that would break builds); does it gradually, with an explanation of what each flag does.

When to use: hardening pass before a release, or to answer “is this project properly configured?” when you inherit a new codebase.

7. device-interaction — the quietest and most useful

Runs as a subagent to verify your app’s behavior on device or simulator. Takes screenshots, inspects the UI hierarchy, simulates taps. This is the skill you pass to Claude when you say “verify this flow works” — it connects to Device Hub, does the interactions, tells you what it found.

When to use: automated functional validation from an agent. Instead of you manually running a flow, the skill runs it and reports.

The real gotcha: 5 are 100% portable, 2 aren’t

Of the 7 skills, 5 are purely about code — they don’t need Xcode running. Those live happily in Claude Desktop or Cursor:

  • swiftui-specialist
  • swiftui-whats-new-27
  • uikit-app-modernization
  • test-modernizer
  • c-bounds-safety

The other two touch project configuration or live hardware, and work best inside Xcode:

  • audit-xcode-security-settings — needs the .xcodeproj to read and modify build settings.
  • device-interaction — needs a simulator or connected device, plus Device Hub APIs to interact.

Outside Xcode those two still export and start, but with reduced functionality. If your flow is mostly code review and refactor, the 5 portable ones cover 90%. The other two you run inside Xcode when you need them.

A concrete example: swiftui-whats-new-27 in action

Say your app compiled against iOS 26 SDK and now you’re migrating. Xcode 27 throws a warning on an old @State, and another on a toolbar modifier. Without the skill:

  • Read the SwiftUI 27 release notes
  • Look up the corresponding WWDC26 session
  • Write the fix

With the skill exported in Claude:

  • “This file throws SwiftUI iOS 27 SDK warnings. Apply the needed changes using swiftui-whats-new-27.”
  • The skill knows exactly which warnings exist, what the idiomatic replacement is, and what NOT to change because it’s a soft-deprecation (still compiles).

It’s the difference between “search + interpret + code” and “code directly.” And since the skill comes from Apple, the fix is what Apple recommends, not what a Medium post suggested.

What the directory looks like after exporting

~/.agents/skills/
├── audit-xcode-security-settings/
│   ├── SKILL.md
│   └── ...
├── c-bounds-safety/
├── device-interaction/
├── swiftui-specialist/
├── swiftui-whats-new-27/
├── test-modernizer/
└── uikit-app-modernization/

Each skill is a folder with its SKILL.md (the description the agent reads) and associated assets. It’s plain text — you can read it, edit it, fork it. The community already started doing that: there’s a mirror at github.com/superagents-lab/xcode27-skills for people who don’t have Xcode 27 installed but want to try.

What these skills do NOT cover (yet)

Useful to know what’s left out:

  • Concurrency and Swift 6.4. There’s no dedicated skill for sendable, isolation, or typed throws. Still official docs territory.
  • SwiftData. Not even with the iOS 27 changes (ResultsObserver, HistoryObserver). I suspect it’ll show up in 27.x.
  • App Intents / Siri. The area with the most migration pressure this year (because of the SiriKit deprecation) — no official skill. Odd.
  • Foundation Models. The framework that got the most attention this year has no skill of its own.

Not that Apple doesn’t cover them in docs — they just didn’t arrive as automated skills. Maybe in Xcode 27.1 or 27.2 more will land.

Adoption in 5 minutes

If you have Xcode 27 installed, this is the minimum flow:

# 1. Export
xcrun agent skills export ~/.agents/skills

# 2. Verify
ls ~/.agents/skills

# 3. Relaunch Claude Desktop / Cursor / Codex
# Skills show up in the picker.

# 4. Try "apply swiftui-whats-new-27 to Feature.swift"

Five minutes and 90% of SwiftUI/UIKit code review runs through skills written by Apple, not generic prompts. Worth it.

Continue the series

Sources