Xcode 27 Went Agentic

The framework news from WWDC26 took the headlines: SwiftUI’s reorder containers, the new document protocols, App Intents background execution. The quieter shift is the one that changes the most about a working day. Xcode 27 has coding agents built into the IDE, and Apple spent five sessions explaining how the toolbar button, the plan command, the artifact pane, and the sub-agent fan-out are supposed to fit together into a way of working.

Apple’s own framing makes the intent plain. “You drive the vision for your code, and Xcode helps you get there faster and with confidence,” the Xcode Intelligence team opens with, before adding that the design goal is “keeping you focused on the work that you enjoy.”¹ The interesting part is not that an LLM writes Swift now. The interesting part is that Apple wired the agent to the same tools you use by hand: the build, the preview renderer, the test runner, the String Catalog, and Xcode Cloud. The agent does not guess whether its code compiles. It builds it, reads the error, and tries again.

TL;DR / Key Takeaways

• Coding agents arrived in Xcode 26.3; Xcode 27 expands the toolset and redesigns the interaction, splitting the screen into a left-side transcript (conversation, tool calls, sub-agents) and a right-side artifacts pane (files, diffs, previews).¹
• A /plan slash command puts the agent in plan mode, so you approve an architecture in markdown before any code gets written, and queued messages let you steer mid-task.¹
• The agent runs Xcode’s real validation tools, build, preview rendering, and the test runner, so it self-verifies as it goes; in the demo it wrote and ran 12 passing test cases for the new feature.¹
• UI prototyping leans on a “go wide, remix, repeat” loop: ask for many named Swift previews at once, then combine the parts you like. Inline annotations and image attachments scope changes to an exact line.²
• Localization runs through the String Catalog and Apple’s per-language style guides; the main conversation fans the work out to sub-agents, and a TRANSLATION.md glossary keeps terminology consistent.³⁴
• Xcode Cloud’s setup got shorter (connect a repo, start the first build) and now drives webhooks and multi-repository builds, the CI half of an agent-heavy workflow that writes more code than before.⁵

The Agent Lives In The Editor Now

Start with the screen, because the layout encodes the model. In Xcode 27 the agent transcript is an editor pane, not a chat drawer bolted to the side. “The transcript has moved into the editor pane, so you can compose it with other editors with tabs, splits, or whatever suits your workflow,” the team explains.⁶ You kick off a conversation from a button in the toolbar center, and option-shift-clicking it opens that conversation as a separate pane so you can read files while the agent works.¹

Apple splits the workspace into a transcript on the left and an artifacts pane on the right; the agent can see source, build settings, open files, and your active selection.

The split matters. “On the left, there is the transcript … including commentary on progress, tool calls, running sub-agents, and more. On the right, we have artifacts. These are things that are created: files, edits, and previews.”¹ Every diff, every new file, every rendered preview shows up as an artifact you review before it becomes load-bearing. The agent operates in the open, with the changes laid out for inspection.

What the agent can see is broader than a typical context window. “When you use agents in Xcode to explore, they can see your whole project. From your source code, build settings, and even open files and active selections.”¹ In the demo, the developer asks for a walkthrough of the data models and view hierarchy, then has the agent write two architecture documents into the repo so the discovery work survives the conversation, “a documented knowledge base in your project” that “can be dynamic and evolve right alongside the codebase.”¹ If you have ever re-explained a codebase to a fresh agent session, the instinct to persist the map will land.

One detail worth flagging for anyone who has used external agents: Apple added an Apple Document Search tool the agent invokes automatically. “Depending on the agent you’re using, its base knowledge might not include the latest framework information. With Apple Document Search, your agent can access high quality documentation.”¹ That addresses the most common failure mode of coding agents on brand-new APIs, confidently calling a symbol that does not exist, by giving the agent a path to current docs at the moment it needs them.

Plan Mode Makes You The Architect

The build half of the workflow runs through plan mode, reached with the /plan slash command. The framing is deliberate: “Plan mode allows you to be the architect, outlining your approach before any code gets written.”¹ The agent gathers context, can spin up sub-agents to explore in parallel, and produces a plan in markdown that you read, edit inline, and approve before implementation begins.⁶

Plan mode turns implementation into a reviewed step. Queued messages and agent clarifying questions create what Apple calls “a tight communication loop” before code lands.

Apple is candid about why planning gets more weight in an agentic workflow. “When you build with agents in Xcode, you can turn ideas into features so quickly … ensuring you have the right plan … becomes a more important step.” The payoff: “refinement is spent polishing up the feature that you want rather than fixing a poorly built foundation.”¹ When the cost of generating code drops toward zero, the cost of generating the wrong code drops too, and the only defense is a plan you actually reviewed.

Two interaction details make the loop work. Queued messages let you add a requirement without interrupting the agent (“Queuing messages like this allows me to express my ideas in the moment rather than waiting for the agent to finish what it’s currently doing”).¹ And the agent asks clarifying questions back, so in the demo the developer picks which insight metrics to surface from a list the agent proposes. The result is a plan the developer co-wrote, not one they rubber-stamped.

Then validation. The agent uses Xcode’s build tool, hits compile errors, and iterates because “build errors are communicated directly to the agent.”¹ It renders previews as artifacts on the current run destination, runs the app on an iPad simulator through Device Hub, and writes unit tests against the existing suite. “The agent wrote a whole suite of tests to validate the new changes, and it was able to run and verify all twelve new test cases passed.”¹ That is the load-bearing distinction from a generic chatbot: the agent closes its own feedback loop with the same instruments you would reach for.

Prototyping Is A Go-Wide Loop

The UI prototyping session is the one that pushes back hardest against handing the work to the machine, which is what makes it the most useful. Sam, a prototyper on the Apple Design Team, states the rule twice: “Do not delegate critical thinking to these tools,” and “Think of coding agents as collaborators in your prototyping process to help you discover what the best experience is. Remember, you always have final say.”²

The session contrasts a vague prompt that anchors you on an arbitrary layout with a specific one that asks for 10 named Swift preview variations to evaluate side by side.

The technique is “go wide, remix, repeat.”² A vague prompt like “create a UI for managing a book club” produces an arbitrary layout you get anchored to. A better prompt asks for multiple variations, names features explicitly, gives stylistic cues (the warmth of a coffee shop, the feel of paper and typography), and gives each variation its own named Swift preview. In the demo that yields 10 distinct directions you click between, after which you tell the agent which elements to combine.² Because previews render in the canvas without a rebuild, the loop is tight enough to treat designs as disposable.

Two refinement tools carry over into the main agent workflow. Image attachments let you communicate intent beyond text, and in the flagship session a developer sketches a chart in Freeform on iPad, sends it, and the agent translates the sketch into a matching Swift Charts line chart, rendering a preview along the way to self-verify.¹ Inline annotations are the sharper instrument: “the annotation doesn’t just say what to change, it shows where, so the result is precise and scoped to exactly what you intended.”¹ You point at the line for a fade-in animation and the line for the trend color, and the surrounding code becomes the context. For animation specifically, Sam recommends asking the agent to build a side-by-side tuning panel with the animation broken into named phases, so you can dial spring stiffness and stagger timing without context-switching.²

Localization Runs Through The String Catalog

Localization is where the orchestration story gets concrete, and where Apple’s integration advantage is hardest to replicate from outside. The setup builds on years of String Catalog work: catalogs began tracking where strings are used, then how they are used to auto-generate comments, and Xcode 27 brings that context to the agent. “Beginning in Xcode 27, you can now translate your strings directly in Xcode using coding agents.”³

The agent prepares the project, builds every target to discover localizable strings, creates String Catalogs, then fans translation out to sub-agents that each carry per-string context.

The flow is precise. The agent tells Xcode to prepare the project, Xcode adds the language and builds all targets so every localizable string is discovered, and any missing String Catalogs get created automatically.³ Then the agent splits strings into batches and “delegat[es] the translation work to individual subagents,” each handed context about where the string is used, similar-terminology strings, and how the same string was translated in other languages.³ The plural handling is a good example of the integration paying off: for %lld items, the sub-agent produces correct French variations (“un élément,” “deux éléments”) because “Xcode makes sure subagents always know which variations are needed, no matter the language.”³

The disambiguation problem is the one to dwell on. Avery from the Localization team opens with the word “book,” which is a thing to read in one sentence and a hotel reservation in another, with separate translations in most languages. “Without further context, the wrong translation could be chosen.”³ The String Catalog supplies that context, and Apple layers on per-language style guides plus whatever guidance you write. The recommended pattern is a TRANSLATION.md file holding a glossary, do-not-translate terms, and tone notes, kept separate from AGENTS.md so the agent only loads it for translation tasks.³ In the demo the developer overrides the default “lieux d’intérêt” for “landmarks” with the more Canadian “attraits,” and a later, unrelated feature picks up “attraits” automatically through the catalog’s cross-string memory, “a translation it would not have chosen by default.”³

The honesty about limits is the part worth keeping. Apple notes that some languages appear less in model training data and may translate worse, recommends a large-context model for the long-running consistency work, and is blunt that your code-reading advantage evaporates for languages you do not speak: “That advantage disappears when using an agent to translate strings into languages we don’t fluently speak.”³ The answer is TestFlight feedback from native speakers, plus rendering the localized UI in a preview to catch truncation early, since French sentences run longer than English. A per-language Generate Translations button lives in the String Catalog itself for focused work.⁴

Xcode Cloud Is The CI Half Of An Agent Workflow

If agents make you write more code faster, something has to catch the regressions, and Apple’s answer is Xcode Cloud, which got noticeably shorter to set up. The Xcode Cloud team draws the line explicitly: “With support for agents arriving in Xcode, a lot of developers are writing more code than ever before … But how do you scale and keep up with the rapid pace of code, new features, and ensure you can catch bugs and performance issues before they reach customer devices? Xcode Cloud is your companion for quality.”⁵

Onboarding is now connect a repository, accept the default workflow, and start the first build; source runs on ephemeral VMs and is never stored.

Setup is a Get Started button, a developer team that prefills from your signing settings, a repository connection, and a first build, with Apple stressing that “Xcode Cloud Builds run on ephemeral virtual machines … None of the source code is ever stored and Apple has no way of accessing it.”⁵ Distribution to internal TestFlight comes through a generated workflow, and the same flow onboards a second app (macOS) in the same workspace without re-authorizing the repo.⁵

The automation tier is where it stops being plain CI. Webhooks fire on a build lifecycle, created, started, and completed, posting a payload to an endpoint of your choice, which is how the demo wires builds into a custom dashboard.⁵ And multi-repository support handles the realistic case where you split a shared framework into its own repo: add the additional Git remote and “Xcode Cloud can now build the project with all the right dependencies in place.”⁵ The “what’s new in Xcode 27” session frames the whole point as catching regressions you would otherwise miss: “shipping updates without knowing whether a regression snuck in is a stunt plane maneuver that no one wants to try.”⁷

Where This Sits Next To Claude Code

The obvious question, if you already run an external coding agent, is whether the in-IDE agent replaces it. The grounded answer is that they solve different problems, and the seam between them is the interesting territory.

Xcode 27’s agent wins on the things only Apple can wire up: the build, preview, and test tools the agent self-verifies against; Apple Document Search for current framework symbols; and the String Catalog’s accumulated per-string localization context an external tool cannot see.¹³ Those are integrations, not models, and they are the durable advantage. An external agent like Claude Code wins outside the Apple toolchain: the shell, repo-wide refactors that span Swift and your backend, the custom MCP tools you already built, and a workflow that is the same across every project.

The two coexist along the same boundary I keep returning to in the App Intents vs. MCP tools piece. Apple’s agent is fluent inside the app and its build graph; the general agent is fluent across your whole machine. Apple did not lock the door: the Xcode agent supports adding your own tools (“Some are built into Xcode, some are provided by Apple framework teams, and you can even add your own”),¹ and Apple standardized on the AGENTS.md convention,³ the same file external agents read. If you have wired Xcode into an external agent through MCP, as in the Xcode + Claude Code setup, the right model is layered, not either-or: the IDE agent for build-loop-tight work, the external agent for everything that crosses the IDE’s edges.

One more note. Apple is upfront that model quality varies, especially across languages, and recommends large-context models for long consistency-heavy tasks.³ That maps onto the Foundation Models agentic workflow tradeoffs: on-device models for the cheap, private, fast turns and a larger model for the work that needs the context window. The same calculus you make picking a model for your own agent code applies inside Xcode.

FAQ

How do I start a coding agent in Xcode 27?

Use the button in the center of the Xcode toolbar to kick off a conversation or task; it opens as an editor pane that works with tabs and splits. Option-shift-clicking opens it as a separate pane so you can read files alongside. The coding assistant sidebar lists parallel conversations and flags ones that need input.¹⁶

What is plan mode and when should I use it?

Plan mode, triggered with the /plan slash command, has the agent gather context and produce an architecture in markdown before writing code. You review it, give inline feedback or queue messages, and approve it to implement. Use it for any non-trivial feature: when code generation is fast, getting the plan right is what prevents you from polishing a poorly built foundation.¹

How does Xcode 27 localization differ from a generic LLM translation?

The agent translates through the String Catalog, which tracks where and how each string is used, and layers Apple’s per-language style guides on top. It fans work out to sub-agents that each receive per-string context, including how a string was translated in other languages. You can add a TRANSLATION.md glossary for overrides. That context lets it disambiguate words like “book” that a context-free model gets wrong.³

Does the in-IDE agent replace Claude Code or other external agents?

No. The Xcode agent is strongest at build-loop-tight work, self-verifying against Xcode’s build, preview, and test tools and reading current Apple docs. External agents are strongest across the shell, repo-wide multi-language refactors, and custom MCP tools. Apple supports adding your own tools and uses the shared AGENTS.md convention, so the setup is layered rather than either-or.¹³

Why does Apple recommend Xcode Cloud alongside agents?

Because agents make developers write more code faster, which raises regression risk. Xcode Cloud builds and tests in parallel across devices and OS versions on ephemeral VMs that never store your source, runs on every commit to chosen branches, and now supports webhooks and multi-repository builds. It is the catch-net for the higher code velocity.⁵

The full Apple Ecosystem cluster: the Xcode + Claude Code MCP setup for driving Xcode from an external agent; hooks for Apple development to enforce quality gates around generated code; the Foundation Models agentic workflow for the on-device-versus-large-model model choice; and the App Intents vs. MCP tools frontier for where Apple’s tool surface meets the open agent ecosystem. The hub is at the Apple Ecosystem Series. For the broader picture of building iOS with agents, see the iOS Agent Development guide.

References