What's New in Xcode 27: The Complete Guide

Xcode 27, announced at WWDC 2026, is the biggest release in years. The headline is agent-driven development: coding agents from Anthropic, Google, and OpenAI now live directly in the editor, plan their work, and validate their own changes. But the release is far broader than AI. The app itself is leaner and faster, there is a new Device Hub for working across simulators and real hardware, agent-assisted localization, a redesigned Organizer that proposes fixes for real crashes, a refreshed Swift Testing suite, and a deep stack of new frameworks (Foundation Models, Core AI, Swift 6.4, SwiftUI) that change what your apps can do.

This is a long, plain-language tour of everything that changed, built from Apple's own WWDC26 sessions and press materials plus early developer coverage.

On this page

• Availability at a glance
• The short version
• A leaner, more personal Xcode
• Coding agents, now in the editor
• How a real session flows
• Apple's own Agent Skills
• Device Hub
• Localization with agents
• A redesigned Organizer
• Testing, Instruments, and Xcode Cloud
• The frameworks that ship alongside it
• Who should care, and how much
• Getting started
• FAQ

Availability at a glance

The short version

A leaner, more personal Xcode

Before any of the AI features, the app itself got lighter. Xcode 27 is now Apple silicon only, roughly 30 percent smaller on disk, with faster performance and a simpler setup. The Apple silicon requirement is not arbitrary: the Neural Engine does the heavy lifting for on-device code completion, so dropping Intel let Apple lean on hardware that every supported Mac now has.

It is also more customizable than it has ever been. The toolbar was redesigned with reorderable controls and a dedicated entry point for coding agents. A new Appearance panel lets you dial in colors and fonts with sliders, pick from preset themes, and assign a per-project theme so you can tell at a glance which project window you are looking at. Predictive inline issues now show up in a subtle style while you type and only escalate to full-intensity warnings and errors after a build, so the editor nags you less mid-thought.

New project workflows round it out: you can spin up an untitled project instantly or open a standalone Swift file with previews and playground-style results, which makes quick prototyping much less ceremonial.

Coding agents, now in the editor

This is the centerpiece. Xcode 27 brings the full power of today's best models and agents from Anthropic, Google, and OpenAI directly into the workflow. Agent conversations live in the editor pane itself with full tab and split support, instead of being boxed into a side panel.

A few things make this more than a chat window:

• Interactive planning. A /plan command (also called plan mode) scopes the work before any code changes happen. Plans show up as editable Markdown artifacts next to the conversation, so you review and adjust what the agent intends to do before it touches your files.
• A real canvas. Conversations can render Markdown and display code changes and previews right alongside the discussion, with multiturn question and answer.
• Queued messages. You can communicate requirements in real time, queuing follow-up instructions while the agent works rather than waiting for it to finish.
• Agents that check their own work. Xcode 27 gives agents the tools to validate what they produce, so they can run autonomously for longer.

The two-tier intelligence model

Xcode 27 splits intelligence into two tiers, which is the key to it being both fast and private.

The local model is tuned to your active Swift and Apple SDK project structure and offers code and documentation suggestions in real time. The cloud agents take the heavy lifting only when a task needs it. You choose your provider in Settings under the Intelligence panel.

Self-validating agents

This is the real shift from assistant to agent. In Xcode 27 an agent can:

• Write unit tests automatically and run them to verify its changes work
• Try ideas in isolation with Swift Playgrounds before committing them
• Check visual changes in SwiftUI previews
• Interact with the simulator through the new Device Hub to validate behavior
• Do all of the above without stopping to ask permission at every step, within bounds you set

Assistants wait for feedback. Agents make decisions and verify their own output, which is what lets them run productively for longer stretches.

Coding Tools

Alongside the conversation interface, the editor gained Coding Tools, modeled on the system-wide Writing Tools UI. These are quick inline actions to fix mistakes, explain a snippet, or generate unit tests for a piece of code on the fly, without opening a full agent conversation.

Open protocols: MCP and ACP

Apple did not just wire in three vendors. It built on open standards:

• Model Context Protocol (MCP) defines what agents can do inside Xcode: read files, build projects, run tests, and access diagnostics, routed through an mcpbridge tool. The Xcode MCP server gained new tools in this release 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.
• Agent Client Protocol (ACP), new in Xcode 27, defines which agents can connect. Any third-party agent that implements ACP can work with Xcode, not just the three named providers.

With plug-ins you can extend Xcode with custom skills, bring in everyday tools through MCP, and connect any ACP-compatible agent. GitHub and Figma are the first to offer one-click installation between their tools and Xcode, so version control data and design files become available to the agents working on your code.

How a real session flows: explore, build, refine, orchestrate

Apple frames the agent workflow in four phases, which is a useful mental model.

Explore. When you join an unfamiliar project, an agent can give you a walkthrough of the data models and view hierarchies, draw on Apple Document Search for accurate, current framework knowledge, and capture what you learn as reusable architecture documents you keep in the project.

Build. Use plan mode to design an architecture before any code is written, communicate requirements in real time with queued messages, and rely on Xcode's build, preview, and test tools to validate features as they are implemented.

Refine. Iterate on visual design with realistic previews (for example Swift Charts with real data), attach images to convey design intent, and drop inline annotations right in your source code to direct targeted changes, keeping creative direction in your hands.

Orchestrate. Describe a high-level goal like "localize this app" or "improve accessibility," and Xcode discovers the right tools and coordinates sub-agents to accomplish it in parallel.

Common workflows this enables: interactive refactoring of a large module (described, planned, approved, then executed in test-validated steps), test-suite generation for an existing module, autonomous bug investigation starting from a crash or failing test, and full feature scaffolding from a plain-language description.

Apple's own Agent Skills

The quieter but genuinely interesting addition: Xcode 27 ships with seven agent skills that Apple wrote itself, bundled into the toolchain. A skill is a focused bundle of guidance that fills the gaps where agents are weakest, namely brand-new APIs, recently deprecated patterns, and platform-specific footguns. The difference now is that the guidance comes from the people who built the frameworks.

Each skill is a folder with a SKILL.md and supporting files, in the same open Agent Skills format anyone can author, just written by Apple. They live inside the toolchain, and one command pulls them all out:

xcrun agent skills export --output-dir ~/Downloads/xcode-skills

That gives you two uses. The obvious one is letting the agents in Xcode use them: an agent loads swiftui-whats-new-27 when you adopt a new API, or audit-xcode-security-settings when you ask it to review your configuration, reading the short description first and pulling in the full instructions only when a task matches, so they stay cheap on context. The second use is for you directly. These are plain Markdown files of Apple's current recommendations, so you can read them as authoritative guidance or feed them into your own tooling outside Xcode. Exporting and reading swiftui-whats-new-27 is one of the fastest ways to see what Apple considers current SwiftUI practice.

If the command is not found, your command line tools are probably still pointed at an older Xcode. In Xcode 27, open Settings, go to the Locations tab, set the Command Line Tools dropdown to Xcode 27, and rerun the export.

Apple's seven skills cover its frameworks, not your project's conventions, so you will still write your own skills for house rules. The format is identical: a folder with a SKILL.md whose YAML header carries a name and a description, where the description is what the agent reads to decide whether to activate. Apple also shipped a separate set of open-source skills with Game Porting Toolkit 4, focused on Metal-specific guidance for bringing games to Apple platforms, which is the same pattern applied to a different domain.

Device Hub

Device Hub is a new app shipping with Xcode 27 that unifies running, inspecting, and evaluating your app across both simulators and physical devices. It has two modes, a compact window and a full window, and gives a consistent experience whether you are pointing at a real iPhone or a simulator.

The interactive canvas lets you work with a device directly: live display, touch input, hardware controls, zoom, a resize mode (useful for testing iPhone Mirroring resizability), and keyboard capture. A sidebar manages your whole device and simulator inventory with filters, sorting, and grouping.

Configuration happens through five inspector panels:

A typical use Apple demonstrated: one developer pairs a device, installs a logging profile, captures diagnostics, and shares the app data; another developer then uses a simulator to reproduce the bug by mirroring the first device's configuration. For automation and CI, the devicectl command-line tool manages devices, installs apps, captures diagnostics, and slots into scripts. Device Hub is also the surface that agents reach into when they need to interact with a running app to verify their changes, which is where the bundled device-interaction skill earns its place.

Localization with agents

Localization is one of the clearest wins for the agent model. In Xcode 27 a coding agent can set up localization for you, create String Catalogs, and generate translations across multiple languages, turning a tedious multi-step chore into something you can kick off and review rather than hand-assemble. We break that workflow down step by step, including where it still needs a native speaker, in Xcode 27 translation agents. And once the UI is localized, the matching move is pricing each market correctly, which we cover in App Store subscription pricing across 25 countries.

A redesigned Organizer that suggests fixes

The Organizer was rebuilt to surface high-impact issues first instead of burying them. It adds new metrics, including storage and animation hitch data, and introduces Metric Goals so you can set targets and track against them. The notable part: it can generate agent-powered fix recommendations for crashes pulled from your shipping app, closing the loop from "users are hitting this" to "here is a proposed fix" inside the same tool.

Testing, Instruments, and Xcode Cloud

Swift Testing. Xcode 27 ships a refreshed Swift Testing macro suite that gives you native, clear, expressive asynchronous unit testing syntax instead of legacy XCTest wrappers. Combined with agents that can write and run tests, the testing story is a major focus this year. For the bidirectional XCTest migration that landed alongside it, see What's New in Swift at WWDC26.

Instruments. A new Top Functions view quickly identifies the most expensive code paths, cutting the time it takes to track down a performance regression. Apple paired this with sessions on improving app responsiveness and profiling agentic experiences.

Xcode Cloud. Now up to 2x faster, with new support for apps that use Metal and for visionOS builds, all running on Apple silicon. A streamlined onboarding flow gets builds and tests running automatically on every commit, with TestFlight and App Store delivery.

Beyond Xcode: the frameworks that ship alongside it

Xcode 27 is the tool, but WWDC 2026 also delivered the frameworks that change what your apps can do. These matter because the same agent tooling helps you adopt them.

Foundation Models

Building on the framework introduced last year, Foundation Models is now a single native Swift API that supports more powerful on-device models with image input, server models, and the ability to build custom skills. Through it you can tap the next generation of Apple Foundation Models, custom-built in collaboration with Google and its Gemini models. Two notable details:

• Developers in the App Store Small Business Program with fewer than 2 million total first-time downloads can access the next-generation Apple Foundation Models running on Private Cloud Compute at no cloud API cost.
• A new language model protocol lets you plug in models of your choice, like Claude or Gemini, or any other provider that implements it. Dynamic Profiles let you change how models interact with your app on the fly.

Core AI

Core AI is a brand-new framework designed to be the best way to run models on device. It provides an architecture optimized for the unified memory and Neural Engine of Apple silicon, letting you deploy full-scale LLMs locally.

Swift 6.4 and SwiftUI

For the full Swift 6.4 rundown, including the ownership changes and the Swift Testing interop, see What's New in Swift at WWDC26.

Tools for games and spatial apps

• Managed Background Assets cut install sizes by downloading only the asset packs for a player's preferred language, with closest-match fallback. A new Steam Asset Converter streamlines adapting PC games for Apple platforms.
• Game Porting Toolkit 4 adds open-source agent skills with Apple-specific Metal best practices to speed up Mac game development.
• Official Unity plug-ins bring native Apple integration (StoreKit and Background Assets) into the Unity workflow for In-App Purchases across Apple platforms.
• Reality Composer Pro 3 lets you build complete spatial experiences in one tool, with Live Previews combined with Mac Virtual Display so edits show immediately.

Who should care, and how much

If you build for Apple platforms, the agent integration is the change that will alter your day-to-day most, especially plan mode and agents that validate their own work before handing it back. If you have avoided AI tooling on privacy grounds, the on-device inline completions are a meaningful concession. If you ship to a global audience, agent-driven localization and the new Organizer fix recommendations remove real grunt work. And even if you never let an agent touch your code, the exported Agent Skills are a genuinely useful, free read on what Apple considers current Swift, SwiftUI, UIKit, testing, and security practice this cycle.

The honest caveats. Most of this is agent-assisted, not agent-automated: planning, localization, and crash fixes still want a human reviewing the output, and the quality of agent work tracks the underlying model you pick. The Apple silicon requirement means Intel Macs are now fully left behind. And as with any first release of a big new system, expect rough edges in the beta. The tooling got much better at making review fast, which is the real story here.

Getting started

1. As an Apple Developer Program member, download the Xcode 27 beta.
2. Open Settings, then the Intelligence panel, and select your preferred agent provider (Anthropic, Google, or OpenAI).
3. Start a conversation with an agent in any file, or use /plan to scope a feature first.
4. Export Apple's bundled skills to read them:

xcrun agent skills export --output-dir ~/Downloads/xcode-skills

FAQ

Is Xcode 27 free?

Yes. Xcode is free, and developer betas for Xcode 27 (alongside iOS 27, iPadOS 27, macOS 27, and the rest) are available now from developer.apple.com. A public release is expected in September 2026.

Does Xcode 27 still run on Intel Macs?

No. Xcode 27 is Apple silicon only. In exchange it is about 30 percent smaller and faster to set up.

Which AI models can I use?

Models and agents from Anthropic, Google, and OpenAI are integrated out of the box, and the Agent Client Protocol lets you connect any agent that implements it, so you are not locked to one provider. You choose in Settings > Intelligence.

Does my code get sent to a server for autocomplete?

No. Inline code completions run on-device on the Apple silicon Neural Engine, so they work offline and your source stays local. Larger agent tasks use the cloud model you choose.

What is the difference between MCP and ACP?

MCP (Model Context Protocol) defines what an agent can do inside Xcode, like reading files, building, running tests, and reading diagnostics. ACP (Agent Client Protocol), new this year, defines which agents are allowed to connect to Xcode.

How do I see Apple's bundled Agent Skills?

Run xcrun agent skills export --output-dir ~/Downloads/xcode-skills. You get seven skill folders you can read as Markdown or hand to an agent. If the command is not found, point your Command Line Tools at Xcode 27 in Settings > Locations.

Is Device Hub a separate app?

It ships with Xcode 27 as a dedicated app for managing simulators and physical devices, with a companion devicectl command-line tool for automation and CI.

Do I need to rewrite code for the SwiftUI performance gains?

No. SwiftUI's more efficient state initialization and faster layout rendering apply without code changes. New APIs like reorderable containers and Spatial Preview are opt-in.

Sources

• What's new in Xcode 27, WWDC26 session 258 (Apple Developer)
• Xcode, agents, and you, WWDC26 session 259 (Apple Developer)
• Get the most out of Device Hub, WWDC26 session 260 (Apple Developer)
• Apple accelerates app development with new intelligence frameworks and advanced tools in Xcode 27 (MacDailyNews)
• Xcode 27: The Future of Agent-Driven Development is Here (DEV Community)
• Xcode 27 Ships With Apple's Own Agent Skills (DEV Community)
• WWDC26: What's New in Xcode 27 for Developers (Appcircle)
• Xcode 27 Unveiled at WWDC 2026: AI Agent Integration and Custom LLM Selection (Technetbook)

Spaceport generates production-ready SwiftUI Xcode projects with the boring-but-essential parts of a paid iOS app already wired up: RevenueCat subscriptions, onboarding, sign-in, analytics, an AI assistant scaffold, App Store Connect pricing across 25 markets, and Swift Skills context files (CLAUDE.md, .cursorrules, skill.json) that point the new Xcode 27 agents at your project's conventions from the first build. From an indie iOS dev, for indie iOS devs.

Read more at spaceport.build