Greetings, traveler!

AI agent skills are reusable sets of instructions that teach an agent how to handle a particular type of task. A skill can define what the agent should inspect, which workflow it should follow, what constraints it must respect, and which reference material it should use. You can read more about it here.

Xcode 27 brings this concept directly into Apple’s development environment. Its coding agents can use guidance written by Apple engineers to work with SwiftUI, modernize UIKit applications, migrate tests, review security settings, and verify an app on a simulator or physical device.

Apple currently includes seven exportable skills with Xcode 27.

SwiftUI Specialist

The swiftui-specialist skill contains Apple’s general guidance for writing and reviewing SwiftUI code.

It covers view structure, data flow, environment values, modifiers, localization, animations, and element identity in containers such as ForEach. It also helps the agent identify APIs that Apple no longer recommends, even when those APIs have not yet received a formal deprecation attribute.

This makes the skill useful for broad tasks such as:

• reviewing an existing SwiftUI feature;
• refactoring a large view;
• checking state ownership;
• correcting unstable identity;
• replacing older patterns with current SwiftUI APIs.

Apple describes the SwiftUI Specialist Skill as a way to apply SwiftUI best practices and improve both code correctness and performance.

What’s New in SwiftUI

The swiftui-whats-new-27 skill focuses on APIs and behavior introduced with the 2027 platform releases.

Its references cover changes such as the @State macro, reorderable containers, expanded swipe action support, toolbar overflow controls, automatic AsyncImage caching, item-based presentation APIs, and updates for document-based applications.

This skill solves a common problem with coding models: their training data may not contain the latest SDK documentation. Instead of relying on the model’s existing knowledge, the agent can load guidance shipped with Xcode 27.

The skill is especially useful when migrating an application to the iOS 27 SDK or reviewing code that should adopt the latest SwiftUI APIs. Apple introduced both SwiftUI skills during its WWDC26 SwiftUI session.

UIKit App Modernization

The uikit-app-modernization skill helps prepare UIKit applications for modern, resizable, multi-window environments.

Older UIKit code often assumes that an application has one screen, one window, and one fixed orientation. This can lead to code built around APIs such as UIScreen.main or global orientation checks.

The skill guides the agent through replacing these assumptions with local information from the current scene, window, view, and trait collection. It can also help migrate an application to the scene lifecycle and handle asymmetric safe areas.

Apple demonstrated this workflow by showing an agent replace main-screen references, move orientation logic toward size classes, and add invalidation where the interface must respond to environmental changes.

Test Modernizer

The test-modernizer skill helps update existing test suites.

It can migrate XCTest code to Swift Testing by replacing XCTest assertions with #expect and #require, converting setup and teardown methods, and restructuring test types where necessary.

The skill also covers newer Swift Testing features, including parameterized tests, traits, confirmations, and improved test organization. It is useful for projects that have already adopted Swift Testing but still use patterns carried over from XCTest.

Its focus is modernization rather than basic test generation. The agent starts from the current test suite and updates it without discarding the intent of the existing tests.

C Bounds Safety

The c-bounds-safety skill provides guidance for adopting Clang’s -fbounds-safety extension.

This extension adds bounds information to C pointers and helps detect out-of-bounds memory access. The skill explains pointer annotations, build settings, incremental adoption, and the runtime failures that can appear when a bounds check detects invalid access.

Although this skill is less relevant to a pure Swift application, it can be useful for projects that contain C, Objective-C, low-level libraries, or imported legacy code.

The skill name and content may change between Xcode 27 beta releases, so exported copies should be treated as version-specific guidance.

Xcode Security Settings Audit

The audit-xcode-security-settings skill reviews the security-related configuration of an Xcode project.

It examines compiler warnings, static analyzer checks, and available hardening settings. Depending on the project, it can recommend features such as pointer authentication, typed allocators, stack initialization, and Enhanced Security options.

Security settings often require gradual adoption. Enabling every available check at once can produce build failures or expose assumptions in older dependencies. The skill therefore treats the audit as a staged process rather than a single configuration change.

This is also one of the skills that benefits from running inside Xcode, where the agent has better access to project settings and target configuration.

Device Interaction

The device-interaction skill allows an agent to verify the result of its work on a simulator or physical device.

The agent can capture screenshots, inspect the UI hierarchy, and perform interactions such as taps, scrolling, swipes, and text input. This turns the validation step into part of the agent workflow instead of stopping after the code compiles.

For example, an agent could implement a settings screen, launch the app, navigate to that screen, interact with its controls, and inspect the result.

This skill depends on tools provided by Xcode. Exporting its Markdown files to another agent does not automatically give that agent control over a simulator or device. The external tool must also have an appropriate integration with Xcode or its own device automation tools.

Apple describes these broader Xcode 27 capabilities as allowing agents to run tests, configure previews, and drive a running application to validate it end to end.

Exporting Xcode skills

The built-in skills are not limited to Xcode’s own coding assistant. Apple provides a command-line export mechanism:

xcrun agent skills export ~/.agents/skills

The command creates Markdown-based skill directories in the selected destination. Each directory contains a SKILL.md file and may include additional references or scripts.

Exporting the current Xcode 27 set produces directories similar to these:

audit-xcode-security-settings
c-bounds-safety
device-interaction
swiftui-specialist
swiftui-whats-new-27
test-modernizer
uikit-app-modernization

Apple showed the same export command during its UIKit modernization session and explained that the generated Markdown files can be imported into other workflows.

Because these files come from the installed Xcode version, the exported set may change as Apple updates Xcode 27.

Using the skills with Codex, Claude, or Cursor

Tools that support the Agent Skills format can discover skills placed in a shared directory such as:

~/.agents/skills

After exporting the skills, restart or refresh the coding tool if they do not appear immediately.

Knowledge-focused skills usually transfer well between agents. swiftui-specialist, swiftui-whats-new-27, and test-modernizer mostly provide instructions and reference material for editing source code.

Tool-dependent skills have more limitations. device-interaction needs access to a running device or simulator, while the security audit works best when the agent can inspect and modify Xcode project settings through Xcode-aware tools.

Xcode 27 can also expose its tools to external agents through its Model Context Protocol integration. Developers can enable this under the Intelligence settings by allowing external agents to use Xcode tools.

Why Apple’s skills matter

A general coding model knows Swift, but it does not automatically know which conventions Apple currently recommends or which APIs changed in the newest SDK.

The new skills give agents a source of versioned, task-specific guidance. They also separate that guidance from the model itself. Apple can update a skill as frameworks and tools change without waiting for a model provider to retrain its model.

The initial collection does not cover every area of iOS development. There are no dedicated built-in skills for topics such as application architecture, Swift Concurrency design, SwiftData modeling, launch performance, or advanced SwiftUI performance analysis.

That leaves room for project-specific and community-maintained skills. Apple’s skills provide the platform guidance, while custom skills can define the architecture, constraints, and workflows of a particular codebase.

Final thoughts

Xcode 27 treats agent skills as part of the development toolchain rather than a collection of prompts hidden inside an assistant.

The seven included skills cover SwiftUI, UIKit modernization, testing, memory safety, project security, and runtime verification. More importantly, Apple lets developers export those skills as Markdown and use them with other compatible agents.

That makes the guidance useful even for teams that continue working with Codex, Claude, Cursor, or another coding environment. The agent may change, but the same Apple-authored instructions can follow the project.