Xcode 27: New Features, Agents, and Breaking Changes Explained

Apple’s app-building tool now has AI agents built in, a brand-new Device Hub, and a few changes that will break some existing projects. Here is what actually changed, in plain English.

Photo by Alexander Sinn on Unsplash

Introduction

If you have ever used an iPhone app, someone built it in Xcode. Xcode is Apple’s free “workshop” for making apps: it is where developers write code, design screens, test on virtual and real devices, hunt down bugs, and finally send the app to the App Store. Every year Apple ships a big new version alongside new versions of iOS, macOS and its other operating systems.

The 2026 edition is Xcode 27. Apple showed it at its WWDC developer conference in June, released developer betas on June 8, 2026, opened App Store submissions with a release candidate on September 10, and, according to developer-blogger Michael Tsai, the final version landed around September 15. A first beta of the follow-up, Xcode 27.1, appeared on September 18.

Why should a non-expert care? Two reasons. First, Xcode 27 is the clearest sign yet that AI “agents” (software that can plan and carry out multi-step coding tasks, not just suggest the next line) are becoming a normal part of how apps get built. Second, it quietly drops support for older Macs and older systems, which affects real people and real businesses.

In this article you will learn:

• What is new in Xcode 27, feature by feature
• What changed for AI coding agents, and which claims are confirmed versus only reported
• What might break if you upgrade
• What developers are saying, including the complaints

A trust note: wherever possible, I lean on Apple’s own release notes, its Xcode Support page and its WWDC26 session “What’s new in Xcode 27”. Those are still Apple describing its own product, so I flag where independent developers add nuance. I also correct one claim that circulated widely in the coverage of this release and turns out to be a two-year-old feature wearing a new headline.

The Big Picture in One Paragraph

Think of previous Xcode versions as a well-equipped workshop where you did all the work yourself. Xcode 27 adds a team of assistants to the workshop (AI agents), a new control room for all your test devices (Device Hub), a fresh coat of paint you can customize (Themes), and better gauges for measuring how your finished app performs (Organizer and Instruments). It also locks the door on some very old tools (Intel Macs, the old linker) to make room.

Photo by Numan Ali on Unsplash

AI Coding Agents Move Into the Editor

A little background

The idea is not brand new. Back in February 2026, Apple announced Xcode 26.3 with support for Anthropic’s Claude Agent and OpenAI’s Codex, and exposed Xcode’s abilities through the Model Context Protocol (MCP). MCP is an open standard, a bit like a universal plug shape, that lets an AI agent connect to a tool (here, Xcode) without custom wiring for each pair.

What Xcode 27 adds

Apple says Xcode 27 brings the “best models and agents from Anthropic, Google, and OpenAI” into the developer’s workflow. The release notes get more specific. Here are the highlights, translated:

• More providers. Google Gemini and Google Antigravity are now available in the coding assistant, and Codex shows up in the notes too, in a bug-fix entry about Apple’s skills not being available to it.
• Planning mode. You can ask an agent to make a plan first. The plan appears as an editable Markdown document (a simple text format with headings and bullet points) next to the conversation, and you can annotate it and approve it before the agent touches any code. The WWDC session shows a /plan command for this and describes sub-agents working in parallel.
• A new home in the editor. The assistant moved out of the side navigator into the main editing area, with tabs and split panes. Code changes, plans and screenshots of your app’s screens show up alongside the conversation.
• Agents that can check their own work. Agents can now boot a simulator, install and launch your app, tap on it, and take screenshots to see whether the result looks right. Apple’s notes say agents can also verify watchOS apps (even turning the Digital Crown) and tvOS apps (using the Siri Remote).
• More debugging powers. The Xcode MCP server gained tools to manipulate a running app, read the debugger console, switch build settings, and inspect entitlements (permissions an app requests) and Info.plist keys.
• Insights from real users. Agents can read information about crashes, energy use, hangs and launch problems affecting your published app, so they can suggest fixes.
• Skills and plugins. Agents can be extended with plugins that bundle “skills” (reusable instruction packs) and MCP servers. Xcode also ships Apple-written specialists for jobs like localization, UIKit resizing and accessibility. Developer Antoine van der Lee lists seven bundled skills and shows a command that exports them so other tools, such as Claude, Codex or Cursor, can use them too.
• Support for the Agent Client Protocol (ACP). Another open standard, this one for connecting editors to agents.
• A security layer. A new setting monitors and controls which files coding agents, and any programs they launch, can touch.
• A headless MCP preview. Beta 5 added a preview of an MCP server that works without an open Xcode workspace, enabled through a command-line tool. Apple’s notes warn that one “approve everything” option is not recommended for use at your desk.

The analogy

Imagine a carpenter who used to have a helper that could only hand over the next nail. Now the helper can draw up a plan, show it to you, build the shelf, stand it up, and photograph it to check it is level. You still sign off on the plan, and you still inspect the shelf.

Which providers, exactly?

Three Apple sources describe the lineup slightly differently, which is worth untangling:

• Apple’s WWDC announcement names “Anthropic, Google, and OpenAI.”
• Apple’s Xcode product page says Xcode supports “the large language model of your choice, including the advanced coding model and agents of Anthropic and OpenAI.”
• The release notes add the specific new arrivals: Google Gemini and Google Antigravity. Codex appears there too, in a bug-fix entry about Apple’s skills not being available to it.

None of these contradict each other; they are just written at different levels of detail, and MCP support means other compatible agents can connect as well. The practical takeaway is to check the Coding Intelligence settings in your own copy rather than trusting any single article’s list.

Photo by Daniel Schludi on Unsplash

The On-Device Completion Story, Corrected

Several sites covering Xcode 27, including Tech Times and Spaceport, presented “code completion runs on the Neural Engine, your source never leaves the machine” as Xcode 27 news. That framing is misleading in two ways, and the real story is more interesting.

What is true and documented. Apple’s Xcode page states that “Predictive code completion — powered by Apple silicon — uses an on-device machine learning model trained for Swift and Apple SDKs.” So yes, there is a genuine on-device completion model, trained specifically for Apple’s languages and frameworks, and it is Apple’s own documentation saying so.

What is misleading. This is not new in Xcode 27. Predictive code completion arrived back in Xcode 16, and as Lickability’s explainer documents, it has always required an Apple silicon Mac with at least 8 GB of memory and roughly 2 GB of disk space for the model itself. Presenting a two-year-old feature as a 2026 headline is the kind of thing that happens when coverage is assembled quickly.

What remains unverified. Apple says “powered by Apple silicon.” It does not, in anything I could find, say the model runs exclusively on the Neural Engine, which is the specific chip section built for machine-learning work. That precise claim is the secondary sites’ addition, not Apple’s. (Spaceport also sells SwiftUI templates, so it has a commercial interest in the topic.)

The accurate mental model is a two-tier one, and it is worth understanding: fast, local, privacy-preserving autocomplete from Apple’s own small model, plus larger cloud-hosted agents from Anthropic, Google or OpenAI that you opt into for heavier work. The first tier keeps your code on your Mac. The second tier, by its nature, does not.

Photo by Matúš Gocman on Unsplash

Device Hub: One Window for Every Test Device

Before, testing an app meant juggling the Simulator (a virtual iPhone on your Mac) and separate windows for physical devices. Xcode 27 replaces that juggling act with Device Hub, described in Apple’s session as a single workspace for both.

Get Rajan Singh’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

What it does, according to Apple:

• Shows simulators and real devices in compact windows sized to match the device, with quick buttons for Home, screenshot and rotate.
• Includes an inspector for testing accessibility settings, contrast, text size, and light or dark mode.
• Supports resizable iPhone Mirroring on macOS 27, useful for checking different window shapes and sizes.
• Lets you pair an iPhone, iPad or Apple Watch running the new operating systems over the network, with no cable, which Apple says also makes watch pairing more reliable.
• Makes ordinary Mac mouse and trackpad gestures (scroll, pinch, rotate) work on standard UIKit components. Apple warns this is a hybrid convenience and not identical to real hardware, so test on a physical iPad with a pointing device for the full picture.
• Adds a pre-built cache to simulator runtimes so a simulator’s first launch is faster.

Developer Michael Tsai’s round-up of WWDC reactions also highlights that Device Hub can expose a mounted view of an app’s file container on a device, which spares developers from exporting data through the Organizer just to look at it. That is a small feature that will likely earn a lot of quiet gratitude.

A New Look: Toolbar, Themes and Everyday Editing

These are the changes you would notice in the first five minutes.

• Redesigned, customizable toolbar. History controls and editor mode switches move into the toolbar, build progress shows under the window title, and the branch picker moves to the bottom bar so long branch names fit. You can add, remove and reorder items.
• Themes. A new Appearance panel offers sliders for text and background intensity, and a color palette that automatically generates all the other colors. You can even assign a different theme to each project, so you can tell “the client app” from “my side project” at a glance.
• Quieter inline issues. Predicted warnings and errors while you type now appear in a subtler style, then become full-strength on build (or disappear if you fix them first).
• Untitled projects and standalone Swift files. You can start a project without naming it, and open a lone Swift file with previews and playgrounds, handy for quick experiments.
• A new Markdown editor. Markdown files render inside Xcode and can be edited with familiar formatting tools.
• Smarter documentation search. You can search developer documentation in natural language, and results are ranked by meaning rather than exact words.

Not everyone is delighted. In the comments Tsai collected, reader reactions included complaints that UI and editor appearance settings are no longer separate, that the new project template chooser feels cluttered, and that the familiar Command-E shortcut (“Use Selection for Find”) stopped working for one user. Earlier, on the announcement post, one commenter called the new interface “slop UI”. These are individual opinions, not measurements, but they show that a redesign always has fans and critics.

Photo by Alexander Andrews on Unsplash

Measuring Your App: Organizer, Instruments and Xcode Cloud

Once an app is out in the world, developers want to know: is it fast, is it stable, is it eating batteries? Xcode has two main tools for that, and both got upgrades.

Organizer (the “how is my live app doing?” dashboard)

• Insights Overview surfaces the highest-impact performance regressions first.
• Hitches replaces the old Scrolling metric. A “hitch” is a visible stutter in an animation; the new metric covers all animations, not only scrolling.
• Storage metrics track app size and data size across releases.
• Metric goals now cover more categories (battery, disk writes, hangs, hitches, memory, storage), with “similar app” comparisons for several of them. A hang is when an app freezes and stops responding.
• Generate Recommendations asks an AI agent to analyze crash, energy, disk write, hang and launch reports, and connects the findings to your source code.

Instruments (the “why is it slow?” microscope)

• A Top Functions view highlights the most expensive pieces of code. In Apple’s demo, it revealed a loop running far more times than needed.
• A new Swift Executors instrument and Swift Task Collection tracks help visualize modern concurrency (code that does several things at once) in Swift.
• A Foundation Models instrument helps debug apps that use Apple’s on-device AI, showing prompts, responses, token usage and speed. (A token is a small chunk of text an AI model reads or writes.)
• Improved System Trace, richer SwiftUI layout information, and command-line improvements to xctrace(Instruments' text-based sibling).

Xcode Cloud

Apple’s session describes a streamlined setup: connect a repository, start a first build, and get automated builds, parallel testing on multiple devices, and TestFlight delivery. Xcode Cloud is Apple’s hosted service for automatically building and testing your app every time code changes.

Under the Hood: Swift 6.4, Testing and Localization

Swift 6.4

Xcode 27 ships with Swift 6.4, the newest version of Apple’s programming language. InfoQ’s coverage of the beta lists items such as:

• anyAppleOS, a single shorthand for "this feature exists on the 27 versions of every Apple platform," which Apple's announcement also highlights
• An @diagnose attribute for fine-grained control of warnings
• A ~Sendable marker, and weak let, for safer multitasking code
• await allowed inside defer cleanup blocks
• Better interoperability between Swift Testing and the older XCTest framework
• A reported up-to-4x speedup in URL parsing

Not all of this is loved. Commenters on Tsai’s Swift 6.4 post worried the language keeps growing more complex and asked whether some features matter to everyday app developers.

Testing

Apple’s notes describe a way to control how UI tests react to app crashes, a new API called XCUIVoiceOverService for testing VoiceOver (Apple's screen reader for blind and low-vision users), and a setting that warns you when an assertion from one test framework is used inside the other. The command-line swift test can also repeat tests until they pass or fail, which is a friendly tool for hunting flaky tests (tests that pass and fail randomly).

Localization

Localization means adapting an app to other languages. In Xcode 27, agents can create String Catalogs (the files holding an app’s text), translate them into one or more languages using project context and language-specific style guides, and mark machine-translated strings in exported files. Apple’s session also pairs this with TestFlight so native speakers can review. Because these are machine translations, human review still matters, which Apple’s own workflow implicitly acknowledges.

Smaller but useful

Icon Composer 2.0 adds a new rendering mode for upcoming 2027 operating systems, #Preview(arguments:) shows a grid of previews for different inputs, and previews can now be viewed in different localizations and contrast settings.

What Changes for Your Setup: Requirements and Breaking Changes

This is the part that can ruin a Monday if you skip it.

Requirements. Per Apple’s notes, Xcode 27 needs a Mac running macOS Tahoe 26.6 or later, and it installs and runs only on Apple silicon Macs (M-series chips). Intel Macs are out. Apps can still be built for Intel; Apple says the macOS 27 SDK supports back-deploying universal apps to macOS 12 and later, and that Intel development remains possible on macOS versions that support Rosetta. Also note that when you target macOS 27.0 or later, Xcode no longer builds for Intel by default, so you must add x86_64 explicitly if you still need it.

Deployment floors. A “deployment target” is the oldest OS version your app promises to support. Apple’s Xcode Support page gives the authoritative ranges for Xcode 27:

PlatformSupported deployment targetsiOS / iPadOS15–27tvOS15–27watchOS9–27visionOS1–27macOS12–27DriverKit21–27

The same page confirms Swift 6.4 as the compiler, with language modes 6, 5, 4.2 and 4 still available, and on-device debugging limited to iOS 17+, tvOS 17+, watchOS 10+ and visionOS 1+. Developer Steve Troughton-Smith, quoted on Tsai’s blog, called the raised floors “devastating for minimum OS deployment targets” for anyone still supporting older systems.

Build breakers, straight from Apple’s notes:

• The old ld64 linker is gone. The release notes are unambiguous: ld64 has been removed and the -ld_classic option is no longer supported. The linker is the tool that stitches compiled pieces into a finished app. If either appears in your build settings, remove it.
• A Swift source break (SE-0508). A computed property with both an init accessor and an array or dictionary literal initial value will not compile if the getter is declared before the init accessor. Apple's stated workaround is to swap them so the init accessor comes first.
• Unique module names. The Swift dependency scanner was optimized, and as a consequence every Clang module reachable from a single scan must now have a unique name. Duplicates may report an error where they were previously tolerated. Apple flags vendored third-party sources that redeclare an SDK module as the common culprit.
• PreviewProvider is deprecated. Use the #Preview macro instead.
• @State initialization order. A third-party migration write-up reports a hard failure in a specific @State pattern. I searched the full release notes and found no such entry, so treat this as one developer's observation rather than a documented change, and test it against your own code.

Stability reports. Tsai’s post collected anecdotes from developers about compiler crashes and binaries that crash on launch on certain 26.4-era systems, and one developer reported an “XCStrings” build error. These are single reports, and betas and early releases always produce some. They are a reason to read Apple’s Known Issues before upgrading a production project, not a verdict on quality.

What the 27.1 beta already tells us

The Xcode 27.1 beta notes, published just three days after the final 27 release, are short but revealing. The beta adds the iOS 27.1 SDK and one preview feature (a Display group in the canvas overrides picker, for previewing on a device’s alternative display). The rest is known issues:

• Mac Catalyst is rough. Projects using iOS 27.1-specific APIs show compile errors when building for Mac Catalyst, and projects targeting iOS 27.1 show no Mac Catalyst run destination at all. Apple gives workarounds for both. Mac Catalyst is the technology for running iPad apps on the Mac.
• Simulator problems. Apple acknowledges that a first Simulator launch “can take several minutes,” which sits awkwardly beside the Xcode 27 improvement meant to speed that up.
• A new device runtime with gaps. The notes mention an iPhone Duo Simulator runtime in which StandBy is unavailable and most app extensions cannot be run or debugged. Apple does not explain the name in these notes, and I am not going to speculate about hardware from a simulator runtime string, but it is there in the official text.

The honest reading: Xcode 27 shipped, and the follow-up is already busy patching platform edges. That is normal, and it is also a reason not to upgrade a production pipeline in week one.

Comparison Table: Before and After

AreaBefore (Xcode 26.x)Xcode 27Agent providersClaude Agent and Codex arrived in 26.3Apple names Anthropic, Google and OpenAI; release notes add Gemini and AntigravityAgent workflowChat-style assistant in a side panelConversations in the editor, first-class plan mode, plugins and skills, ACP supportAgent verificationPreviews and buildsAlso boots simulators, taps the UI, screenshots, verifies watchOS and tvOSDevice testingSimulator and physical devices handled separatelyDevice Hub: one workspace, cable-free pairing on new OS versionsOrganizer scrolling metricScrollingHitches (all animations) plus Storage and goalsPreview codePreviewProviderPreviewProvider deprecated; #Preview preferredLinkerld64 / -ld_classic availableld64 removedMac to run XcodeIntel and Apple siliconApple silicon only, macOS Tahoe 26.6+Swift versionSwift 6.xSwift 6.4

The Xcode 27 column draws on Apple’s release notes and Xcode Support page. The 26.x baseline column is assembled from Apple’s February announcement and the wording of the 27 notes, since Apple does not publish a single side-by-side comparison.

What This Means for Different Readers

For iOS and Mac developers. Budget time to upgrade, but do it deliberately: check your linker flags, module maps, and preview code first, and confirm any Mac in your build pipeline is Apple silicon on Tahoe 26.6 or later. Because of the April 2027 SDK requirement, this is not optional forever.

For teams and engineering managers. The agent features create new questions about review, security and cost. Plans are approved by humans, and there is a security layer for file access, but decisions about which provider to use and what an agent may touch are still yours. Apple’s own security note is a good reminder that “approve everything” is a poor default in a shared environment.

For CI/CD owners. Intel build machines can no longer run Xcode 27. If your pipeline still uses them, that is a hardware plan, not just a software update.

For beginners. Xcode is getting friendlier: untitled projects, standalone files, quick previews, and an assistant that can explain and scaffold. That lowers the barrier, but it does not replace understanding what the code does.

For designers and product folks. Device Hub’s contrast, text-size and appearance controls make accessibility and design testing easier to do early instead of at the end.

Conclusion

Xcode 27 is best understood as two releases in one. The visible one is a friendlier workshop: a customizable toolbar, themes, Device Hub, better performance dashboards. The structural one is a bet that AI agents will handle more and more of the routine work, with humans reviewing plans and results, alongside a firm push to leave Intel Macs and older toolchains behind.

Neither part is hype-free. Apple’s feature list is impressive but self-reported, no independent benchmarks of the agent workflow exist yet, some of the coverage around this release recycled an old feature as news, and early users are already reporting bugs, annoyances and hard build breaks. The 27.1 beta notes suggest the platform edges are still being sanded.

The sensible approach is the boring one: read the release notes, check your deployment targets against Apple’s support page, upgrade a branch before your main project, keep a human on every plan an agent proposes, and enjoy the parts that make your day easier. There are more of those than the complaints suggest.

About the Author

I’m Rajan Singh, a Staff iOS Engineer and Mobile Platform Lead. I’ve spent 10+ years turning caffeine into Swift — building SDKs, mobile observability tooling, and the kind of platform infrastructure that engineers only notice when it breaks (which, I insist, is rarely). I write on Medium as @rajanTheSilentCompiler, a name I earned the honest way: by saying very little in meetings and letting the build logs do the talking.

These days I split my time between shipping iOS at scale, glancing over at Android when no one’s watching, and trying to teach large language models to write Swift better than I can — a plan with an obvious flaw I’ve chosen to ignore.

Follow me for the latest on iOS, Android, and AI — explained for humans, with the occasional joke that compiles on the first try.

📝 Medium: @rajanTheSilentCompiler · 💻 GitHub: BholuSingh · 🔗 LinkedIn: rajan-singh