On this page · 14 sections
- The problem with chat-style AI coding
- Agents and chat providers are different
- What Xcode 27 adds
- From code generation to task-oriented work
- Planning before changing code
- Agents can check their own work
- Skills, specialists, plug-ins, MCP and ACP
- External agents: Claude Code, Codex and others
- Why project context matters
- Giving agents access safely
- A practical Xcode 27 agent workflow
- What changes for developers
- How eCorpIT can help
- References
Summary. Agentic coding arrived in Xcode 26.3 in February 2026, with Anthropic's Claude Agent and OpenAI's Codex. Xcode 27 extends it in four ways. Plans are now editable documents you approve before code changes. Agents can drive simulators and read debugger output. A broader set of MCP tools reaches schemes, build settings, entitlements and translations. Plug-ins, skills and Apple-built specialists extend the system. Gemini and the Agent Client Protocol came in Xcode 26.6, and Google Antigravity is new in Xcode 27. This guide explains how these pieces fix the context and verification gaps of chat-style AI coding, and where developers still have to decide.
AI coding assistants can generate code quickly, but generating code is only one part of software development. A real Xcode project also means understanding the existing architecture, changing several files consistently, building, running tests, checking the UI on a simulator, inspecting build settings, debugging failures and reviewing what changed.
That is the gap Xcode's coding intelligence is closing. Instead of an AI model in a separate chat window that only produces text, agents in Xcode get project context and Xcode capabilities. In Xcode 27 they can plan, edit code, build and test, render previews, use simulators, work with translations, and be extended with skills, plug-ins and MCP servers.
About this article. This guide is based on Apple's Xcode 26.3, 26.6, 27 and 27.2 beta release notes, Apple's coding intelligence documentation, Apple's WWDC26 sessions and Apple Newsroom, as checked on 17 October 2026. Xcode 27.1 is the current release and Xcode 27.2 is in beta. Researched with AI assistance and reviewed by our editorial team.
The problem with chat-style AI coding
A conventional AI coding workflow often looks like this: developer, then AI chat, then generated code, then copy and paste into Xcode, then build, then an error, then back to the AI to explain it, and round again.
The problem is often not the quality of the code. It is context and verification. A standalone assistant may not know:
- which scheme and run destination are active;
- what the build settings and entitlements are;
- what the current compiler errors say;
- what the app looks like at runtime;
- whether a SwiftUI layout works on the target device;
- whether a localisation change is complete;
- whether a change breaks something elsewhere.
The developer becomes the bridge between the model and the IDE, which means constant context switching. Apple's documentation describes the alternative: when you choose an agent in the coding assistant, it automatically has access to Xcode capabilities such as building and testing your app.
Agents and chat providers are different
Xcode separates two kinds of intelligence. Agents, such as Claude Agent, Codex, Gemini and Antigravity, work through Xcode's tools: they can build, test and iterate on their own. Chat providers, such as ChatGPT in Xcode, Claude models or any provider that supports the Chat Completions API, answer prompts and propose code, and you can let them apply changes, but they do not drive Xcode's tools in the same way. This article is about agents.
Our comparison of Claude, Codex and Gemini in Xcode covers how the agents themselves differ.
What Xcode 27 adds
The Xcode 27 release notes list these coding intelligence changes, among others:
- Planning as a first-class workflow, with editable Markdown plans.
- Agent-generated code diffs, plans and SwiftUI preview snapshots shown as artifacts next to the conversation.
- Agents that boot simulators, install and launch apps, synthesise touch events and capture screenshots, plus watchOS and tvOS verification.
- New MCP tools for debugging, schemes, run destinations, build settings, compiler flags, entitlements and Info.plist keys.
- MCP tools to read, plan and edit translations in String Catalog files.
- Apple-built specialists for tasks like localisation, UIKit resizing and accessibility.
- Plug-ins that contain skills, MCP servers and Agent Client Protocol agent configurations, with skills invokable as slash commands with completion.
- A filesystem security layer for agents and the processes they spawn.
- Project insights about crashes, disk writes, energy use, hangs and launch issues.
Some foundations are older. Agents that build and test, and MCP access for outside tools, came in Xcode 26.3. Gemini, the Agent Client Protocol and the first preview-variant rendering came in Xcode 26.6. Xcode 27 is the release that ties them into one workflow.
From code generation to task-oriented work
The central change is from completing code to working on tasks. A developer can give an agent a higher-level job, for example: add a settings screen that supports dark mode, saves the user's choice and fits the existing navigation. The agent then explores the project, plans and implements, instead of returning an isolated snippet.
Xcode presents the responses and project changes for review. You can keep prompting, click Undo Changes, or roll back through the conversation History, which needs the project to be in a Git repository.
The unit of work changes from prompt and snippet to task, context, plan, changes, verification and review. That matters most in large apps, where the right answer depends on the architecture already in place.
Planning before changing code
In Xcode 27, plans appear as editable Markdown documents next to the conversation. You can review them, annotate them, discuss changes and approve them before the agent goes ahead.
Plan mode is optional. Xcode enters it automatically when your prompt asks for a plan, or you can type /plan; you leave it by typing /exit and choosing /exit-plan. Without plan mode, an agent edits directly.
Planning fixes a common failure of automated coding: changes that are technically valid but do not fit the app. Ask for authentication without a plan and an agent might build a new service, login screen, session model and token storage, while the app already has a repository layer, a central API client, dependency injection and a session manager. A plan gives you the chance to say so before any code is written:
- You describe the requirement.
- The agent reads the project.
- The agent proposes a plan.
- You review and annotate it.
- You approve.
- The agent implements it.
Architectural review becomes part of the workflow instead of something that happens after the code exists.
Agents can check their own work
Generated code is more useful when the agent can test it. Xcode 27 lets agents boot simulators, install and launch apps, synthesise touch events and capture screenshots to verify UI behaviour. They can also verify watchOS apps, including Digital Crown and button presses, and tvOS apps through Siri Remote navigation.
The Preview Snapshot MCP tool renders variants such as light and dark appearance, portrait and landscape orientation, type-size overrides, widget timelines and Live Activity states.
Take a simple request: fix the layout so the button does not sit under the keyboard. Writing a new layout is only half the job. The full loop is to change the view, build, launch the app, reach the right state, inspect the UI, capture the result, adjust and check again. Xcode 27 moves more of that loop into the agent's hands.
The aim is not an agent that never errs. It is an agent with enough tools to catch its own wrong assumptions through build, runtime and UI feedback before it hands the result back.
Skills, specialists, plug-ins, MCP and ACP
Xcode's agent system is not one model. It is a combination of agents, skills, specialists, plug-ins and tools.
Skills are reusable instructions for a task; Apple describes them as simple Markdown files. Xcode includes built-in skills, you can invoke a skill as a slash command, and typing / lists them all. You can also add your own skills and MCP servers in each agent's configuration folder under ~/Library/Developer/Xcode/CodingAssistant, which applies when the agent runs in Xcode.
Apple-built specialists handle targeted tasks such as localisation, UIKit resizing and accessibility.
Plug-ins package skills, MCP servers, subagents and Agent Client Protocol agent configurations. You add them under the Plug-ins row in Xcode's Intelligence settings. Apple's announcement named GitHub and Figma as the first to offer installation into Xcode.
The Model Context Protocol (MCP) gives agents a standard way to call tools. Xcode runs an MCP server that exposes Xcode functionality, and Xcode 27 adds tools for the debugger, active run state and console, schemes, run destinations, build settings, compiler flags, entitlements, Info.plist keys, preview rendering and translations. Xcode 27.2 beta adds a tool that reports code coverage.
The Agent Client Protocol (ACP) lets you add an agent that Xcode does not list. In Intelligence settings, under Agents, you click Add an Agent, and the agent then runs inside Xcode's coding assistant. That is different from an external agent, described below.
| Component | What it does |
|---|---|
| Agent | Carries out the development task using Xcode's tools |
| Skill | Reusable instructions for a type of task, invoked as a slash command |
| Specialist | An Apple-built helper for a focused area such as localisation |
| Plug-in | A package of skills, MCP servers, subagents and agent configurations |
| MCP | The protocol agents use to call tools, including Xcode's own |
| ACP | The protocol for adding other agents into Xcode's coding assistant |
External agents: Claude Code, Codex and others
An external agent runs outside Xcode, such as Claude Code or Codex in a terminal, and connects to Xcode's MCP server. In Xcode, choose Settings, then Intelligence, and under Model Context Protocol turn on Allow external agents to use Xcode tools. This is one setting for all external agents. Then configure the agent with xcrun mcpbridge; Apple gives these examples:
claude mcp add --transport stdio xcode -- xcrun mcpbridge
codex mcp add xcode -- xcrun mcpbridge
Open your project in Xcode before you prompt the external agent; Xcode alerts you when the agent connects and while it is active. You can add hints about your project in files such as AGENTS.md or CLAUDE.md, wherever the agent reads them.
Xcode 27 also has an early preview of an MCP server that works without an open Xcode workspace, enabled with sudo xcrun mcp-server enable. It can give code-signed agents longer-lived permission for projects in a directory tree. The security trade-offs of that preview are covered in our Xcode 27 agent security guide.
Why project context matters
Incomplete context is one of the hardest problems in AI-assisted development: an agent can write valid Swift that still does not fit the app. Depending on what you enable, agents in Xcode can work with project files, build configuration, schemes, run destinations, debugger information, preview snapshots, localisation resources and project diagnostics. Xcode's Organizer can also start an agent conversation from a crash, energy, disk-write, hang or launch report through its Generate Recommendations option.
A project file agents can read
Xcode 27.2, now in beta, adds a JSON project configuration format with the .xcproj extension, which sits inside the .xcodeproj bundle. Earlier releases used a property-list file with the .pbxproj extension. Apple describes the JSON format as smaller, hierarchical and self-describing, easier to compare in source control, less prone to merge conflicts because configuration changes are isolated, and easier for coding agents to edit.
In Xcode 27.2 and later the JSON file is the default format, and you can switch an existing project to it in the File inspector. The .xcproj format works only in Xcode 27 and later, so a team with anyone still on Xcode 26 should wait before switching. Apple has published the format as open source.
For agent work, a readable project file means build-setting and target changes show up as clean diffs that people can review.
Giving agents access safely
An agent that can read files, change code, run commands, build apps and start processes has far more authority than one that only writes text. Xcode gives you several controls:
- A filesystem security layer for agents and the processes they spawn, which you have to turn on, and which Apple's WWDC26 presentation says relies on new macOS 27 features.
- Permission lists for the commands and tools agents may use; Apple's setup guide says you control which commands, tools and skills agents use.
- Plan review before implementation, and code review afterwards.
- For managed Macs, a device management key,
CodingAssistantAllowExternalIntegrations, that turns the coding assistant off.
The principle is simple: more agent capability needs clearer permission boundaries. Our Xcode 27 agent security guide covers the details and a checklist.
A practical Xcode 27 agent workflow
- Describe the requirement. Give the engineering task, not a request for snippets: for example, add offline caching to the profile screen without changing the navigation.
- Let the agent read the project. It should find the architecture, the relevant files, the API and persistence layers, the UI entry points and the tests.
- Ask for a plan. Use
/plan, then review the files to change, new components, data flow, testing approach and risks.
- Approve the implementation. Annotate anything unclear first.
- Build and test. The agent uses Xcode's tools to build and run the tests and fixes what fails.
- Verify the UI. For UI work, the agent drives a simulator and captures screenshots or preview snapshots.
- Review the artifacts. Read the diffs, plans and snapshots, and give feedback in context.
- Iterate or roll back. Continue the conversation, undo changes or use History in a Git repository.
The agent moves from code generator to participant in the development loop.
What changes for developers
Xcode 27 does not remove the need to understand architecture or review code. It moves where the effort goes.
Agents can take on much of the mechanical work: repetitive and project-wide edits, localisation, first drafts of tests, refactoring, UI checks and the build-and-fix loop.
Developers still decide:
- what architecture to use and which APIs are appropriate;
- what data the app should access;
- which changes are safe and what must be tested;
- which permissions an agent gets;
- whether the result actually meets the requirement.
A useful mental model: the agent handles implementation, exploration and verification; the developer owns requirements, architecture, review and final approval. If you want to measure whether agents are helping, our guide to measuring AI coding agent productivity sets out the metrics.
How eCorpIT can help
eCorpIT is a Gurugram-based technology organisation, founded in 2021, assessed at CMMI Level 5 and MSME certified, with senior-led engineering teams working across AWS, Microsoft and Google platforms. Our iOS teams set up Xcode's coding agents for client projects, with plan-first workflows, permission settings, Git-based review and MCP connections for external agents, so the speed gain does not come at the cost of control. Talk to us at /contact-us/.
Last updated: 17 October 2026.
