On November 6, 2026, a 15-line change was merged into anthropics/claude-plugins-official, the catalog Claude Code registers for you the first time you open an interactive terminal session. It adds a plugin called xcode, and the entry names its author as Apple Inc. By November 8 developers on X were passing around the install command as if it were a new download.

The install really is one line. The interesting part is how little of the plugin is in that catalog. Anthropic's repository holds a shell command, and the plugin itself is generated on your Mac by whichever Xcode you have selected. That design decides how it updates, what breaks on a teammate's machine, and which of your older Xcode and Claude Code setups will now overlap with it.

This guide covers what the entry says, what the plugin contains according to people who have opened it, how to install it, and what to look at before you let an agent build and tap through your app. A short script near the middle prints the contents of your own copy and flags overlapping setups.

What was merged, and what wasn't announced

Pull request #6259 was opened on September 18 by GitHub user jonathanpenn with the description "Adds Apple xcode plugin to the official marketplace." A second pull request, #6338, carried the same change onto a branch inside Anthropic's repository so its checks could run. It was merged on November 6 at 00:55 UTC. A related change, #7015, re-pinned the catalog's validator and allowed the new command source type for this entry.

Here is the whole addition:

{
  "name": "xcode",
  "displayName": "Xcode",
  "description": "Work with Xcode projects from Claude Code: build, run, and test schemes, render SwiftUI previews, drive simulators and devices, read build logs and diagnostics, and search Apple developer documentation.",
  "author": { "name": "Apple Inc." },
  "category": "development",
  "source": {
    "source": "command",
    "command": "xcrun agent plugin path --plugin-format claude",
    "mode": "link"
  },
  "homepage": "https://developer.apple.com/xcode/"
}

Two limits on what that proves. The author field is text in a JSON file, and the pull request does not state who employs its original author. What backs it up is the command itself, because xcrun agent ships with Xcode and generates the files. Apple's own page, Giving external agents access to Xcode, still described only the older claude mcp add route when it was read for this post on November 8, and it doesn't mention the plugin. So treat "Apple released a plugin" as a reasonable reading of the entry and the tool, without an Apple announcement behind it yet.

Why the catalog holds a command instead of files

Most catalog entries point at a directory or a Git repository. A command source points at a program on your machine, which has to print one line, the absolute path of a plugin directory, and exit 0 within the timeout. Anthropic's documentation describes the use case as "an IDE that renders its plugin for the toolchain the user has selected," which fits Xcode closely.

Four consequences follow, all from that same reference page and its companions:

  • Claude Code needs to be version 2.1.229 or later, since that is when the command source type arrived.
  • Claude Code shows you the whole command and asks you to accept it before running it. A script has nobody to answer, so it needs --yes.
  • An administrator can turn off this source type entirely with the disableCommandPluginSources setting. If your company manages Claude Code, the install may be refused for that reason.
  • The entry uses "mode": "link", so nothing is copied into the plugin cache. Claude Code links to the directory Xcode printed and loads those files in place.

Link mode has one more effect worth knowing. The plugin's version comes from the printed directory's real path and its top-level entries, with no hash of the files inside. New content is signaled by printing a different path.

What the generated plugin contains

The clearest public look inside comes from a DevelopersIO write-up dated September 30, which ran the same command by hand on Xcode 27. On that machine the command produced this path:

~/Library/Developer/Xcode/CodingAssistant/ExportedPlugins/27A266a/claude

The folder held .claude-plugin/plugin.json, a .mcp.json registering Xcode's MCP server, and a skills/ directory. Skills carried the prefix xcode-integration:, and the server appeared as plugin:xcode-integration:xcode. That prefix makes sense under Claude Code's loading rules: you install by the catalog's name, xcode, while components are namespaced under the name in the plugin's own manifest.

The skills in that write-up covered SwiftUI and App Intents best practices and what's new in iOS 27, moving XCTest suites to Swift Testing, UIKit multi-window migration, C bounds safety, three accessibility audits, String Catalog translation, a security build settings audit and a device-interaction skill that operates simulators.

Don't expect that exact list on your Mac. Published counts differ: SwiftLee exported 7 skills, giginet exported 10, and DevelopersIO listed 15 inside the plugin. Those are different commands and different builds, and giginet notes that skills change often, with one added around Xcode 27.2 beta 2. The script below prints what you actually have.

The difference between the plugin and a plain skills export matters for one skill in particular. SwiftLee found that device-interaction does not work outside Xcode when exported as a standalone skill, because it needs tools that only Xcode's agent provides. In the plugin, the MCP server travels with the skills, and DevelopersIO was able to run it against a simulator, with the project open in Xcode. Skills such as swiftui-specialist only read and edit source files, so they work either way.

Check these before you install

  1. Run claude --version and confirm 2.1.229 or later.
  2. Run xcode-select -p and confirm it points at Xcode 27. Every public report of xcrun agent plugin found for this post used Xcode 27, so a machine still on Xcode 26 should be expected to fail until proven otherwise.
  3. Run xcrun agent plugin path --plugin-format claude yourself. It should print one absolute path. Claude Code treats a non-zero exit, a timeout or any other output as a failed install, so this is your dry run.
  4. In Xcode, open Settings, choose Intelligence, and under Model Context Protocol set "Allow External Agents to Use Xcode Tools" to "While Xcode is Open" or Always. Apple's page lists Never as the off position. For a first trial, "While Xcode is Open" keeps the access tied to a window you can see.

Install it

Inside a Claude Code session:

/plugin install xcode@claude-plugins-official

In a session this opens the details pane and installs nothing until you confirm. Read the command it shows you, which should match the entry above exactly, and choose a scope. User scope turns it on in every project on the machine. Local scope turns it on for you in this repository only, which is the sensible choice for a first trial. Project scope writes to the shared .claude/settings.json, and each collaborator still has to install it once.

From a shell or a setup script:

claude plugin install xcode@claude-plugins-official --scope local --yes

Use --yes only after you have read the command, since it accepts it on your behalf. The official catalog might not be registered on a brand-new machine where nobody has opened an interactive session. In that case run claude plugin marketplace add anthropics/claude-plugins-official first.

Afterwards, these two confirm what you got:

claude plugin list
claude plugin details xcode

The second prints a component inventory and an Always-on line, the number of tokens the plugin adds to every session where it's enabled. Check that figure against your own budget. A plugin with this many skills costs something even in sessions that never touch Swift, which is another reason to prefer local scope in a repository that needs it over user scope on a machine that also does web work.

A script that inspects your copy and finds overlaps

Run this from a project root, ideally before you install the plugin. It calls xcrun and xcode-select, reads config files, and prints what the generated plugin contains. It uses only the Python standard library. Note that running the xcrun agent command may itself generate the plugin folder under ~/Library/Developer/Xcode, as DevelopersIO's path suggests. The script changes nothing in your project or your Claude Code settings.

#!/usr/bin/env python3
"""Inspect Xcode's Claude Code plugin and look for setups that overlap it.

Run from a project root. Calls xcrun and xcode-select, reads config files,
and changes nothing in your project or Claude Code settings.
"""
import json
import os
import pathlib
import subprocess
import sys

HOME = pathlib.Path.home()
CWD = pathlib.Path.cwd()
PLUGIN_ID = "xcode@claude-plugins-official"


def run(args):
    try:
        done = subprocess.run(args, capture_output=True, text=True, timeout=120)
    except (OSError, subprocess.TimeoutExpired) as err:
        return 1, "", str(err)
    return done.returncode, done.stdout.strip(), done.stderr.strip()


def load(path):
    try:
        return json.loads(pathlib.Path(path).read_text())
    except (OSError, ValueError):
        return None


def bridges(servers):
    """Names of MCP servers whose command line mentions mcpbridge."""
    found = []
    for name, spec in (servers or {}).items():
        if not isinstance(spec, dict):
            continue
        line = " ".join([str(spec.get("command", ""))] + [str(a) for a in spec.get("args", [])])
        if "mcpbridge" in line:
            found.append(name)
    return found


def find_records(node, key):
    """Walk parsed JSON and return every value stored under key."""
    hits = []
    if isinstance(node, dict):
        for k, v in node.items():
            if k == key:
                hits.append(v)
            hits.extend(find_records(v, key))
    elif isinstance(node, list):
        for item in node:
            hits.extend(find_records(item, key))
    return hits


def main():
    code, out, err = run(["xcrun", "agent", "plugin", "path", "--plugin-format", "claude"])
    lines = out.splitlines()
    if code != 0 or len(lines) != 1 or not lines[0].startswith("/"):
        print("FAIL  xcrun did not print one absolute path. A marketplace install would fail too.")
        print("      exit:", code, "| stdout:", out[:200] or "(empty)", "| stderr:", err[:200] or "(empty)")
        return 1

    root = pathlib.Path(lines[0])
    _, selected = run(["xcode-select", "-p"])[:2]
    print("Active Xcode :", os.environ.get("DEVELOPER_DIR") or selected or "unknown")
    print("Plugin dir   :", root)

    manifest = load(root / ".claude-plugin" / "plugin.json") or {}
    print("Manifest name:", manifest.get("name", "(not found)"))

    servers = (load(root / ".mcp.json") or {}).get("mcpServers", {})
    print("MCP servers  :", len(servers))
    for name, spec in servers.items():
        print("   ", name, "->", spec.get("command", spec.get("url", "?")), " ".join(spec.get("args", [])))

    skill_dir = root / "skills"
    skills = sorted(p.parent.name for p in skill_dir.glob("*/SKILL.md"))
    print("Skills       :", len(skills))
    print("   ", ", ".join(skills) or "(none)")

    extras = []
    if (root / "hooks" / "hooks.json").exists():
        extras.append("hooks/hooks.json")
    if (root / "bin").is_dir():
        extras.append("bin/ (" + str(sum(1 for _ in (root / "bin").iterdir())) + " files)")
    for folder in ("agents", "commands", "monitors"):
        if (root / folder).exists():
            extras.append(folder + "/")
    print("Code that runs by itself or adds components:", ", ".join(extras) or "none found")

    problems = []

    user_config = load(HOME / ".claude.json") or {}
    user_bridges = bridges(user_config.get("mcpServers"))
    project_block = (user_config.get("projects") or {}).get(str(CWD), {})
    local_bridges = bridges(project_block.get("mcpServers"))
    repo_bridges = bridges((load(CWD / ".mcp.json") or {}).get("mcpServers"))
    for scope, names in (("user", user_bridges), ("local", local_bridges), ("project .mcp.json", repo_bridges)):
        for name in names:
            problems.append("Separate mcpbridge server '" + name + "' at " + scope + " scope")

    if os.environ.get("CLAUDE_CODE_PLUGIN_DIRS"):
        problems.append("CLAUDE_CODE_PLUGIN_DIRS is set. A same-named plugin there silently replaces the marketplace copy")

    for folder in (HOME / ".claude" / "skills", CWD / ".claude" / "skills", HOME / ".agents" / "skills"):
        doubled = [s for s in skills if (folder / s / "SKILL.md").exists()]
        if doubled:
            problems.append(str(folder) + " already has " + str(len(doubled)) + " of these skills: " + ", ".join(doubled))

    installed = load(HOME / ".claude" / "plugins" / "installed_plugins.json")
    records = find_records(installed, PLUGIN_ID) if installed else []
    print("Marketplace install:", json.dumps(records) if records else "not installed")

    if problems:
        print("\nOverlaps to clean up:")
        for item in problems:
            print("  -", item)
        return 2
    print("\nNo overlapping setup found.")
    return 0


if __name__ == "__main__":
    sys.exit(main())

An exit code of 0 means no overlap, 1 means xcrun didn't produce a usable path, and 2 means it found something to clean up. It was tested on Linux against stand-in xcrun and xcode-select programs and sample config files covering a clean setup, a failing xcrun and every overlap below. It has not been run against a real Xcode install, so the layout it expects comes from the DevelopersIO description. If a future build moves things, the inventory lines will read zero rather than crash, and that tells you to look in the folder yourself.

Three older setups that overlap with it

If you were already using Xcode with Claude Code, you probably have at least one of these. The docs don't describe how a plugin and a hand-added copy of the same tools interact, so the advice in this section is a judgment call: one source for each thing is easier to reason about.

A hand-added mcpbridge server

Apple's documented route is claude mcp add --transport stdio xcode -- xcrun mcpbridge. If you ran that, you have a server named xcode, and the plugin adds another that DevelopersIO saw as plugin:xcode-integration:xcode. Claude then sees two sets of the same tools. Check with claude mcp list, then remove the one you added by hand, using the scope it was added at:

claude mcp remove xcode --scope user

Before you do, look at the old entry. Some setups pin DEVELOPER_DIR in it so the agent can use a beta while xcode-select stays on the release build, a pattern Mehmet Baykar documents. The catalog entry has no such setting. If you rely on that split, keep your hand-made server and skip the plugin, or accept that the plugin follows whichever Xcode xcrun resolves.

The CLAUDE_CODE_PLUGIN_DIRS line in your shell profile

DevelopersIO's recipe adds this to ~/.zshrc:

export CLAUDE_CODE_PLUGIN_DIRS="$(xcrun agent plugin path --plugin-format claude)"

This one is easy to miss. Anthropic's loading reference says a plugin loaded through that variable replaces a same-named marketplace plugin silently, while claude plugin list still shows the marketplace row as enabled. You would believe you were on the marketplace install while running the session-only copy. If you switch to the catalog entry, delete that line and open a new terminal.

Skills exported to a skills folder

Anyone who followed the earlier guides ran some form of xcrun agent skills export. The published examples disagree on the syntax. SwiftLee passes the folder directly, and giginet and Baykar use --output-dir, so check xcrun agent skills export --help on your build. Exported copies in ~/.claude/skills or a repo's .claude/skills stay frozen at the Xcode version that wrote them, and they sit beside the plugin's namespaced versions. Delete the ones the script names so Claude has a single current copy of each.

What happens when Xcode changes

With a normal plugin, an update arrives when the catalog changes. Here the catalog will probably stay the same for months, and your Xcode is what moves. Claude Code's loading reference says it re-runs an accepted command when you install or update the plugin, and once per session in the background shortly after startup, regardless of the marketplace's auto-update setting. If the result differs, it installs the new version and reloads it, or asks you to run /reload-plugins when an in-place reload would invalidate the prompt cache.

Three practical points come out of that.

Switching Xcode changes the agent's tools and instructions. The path DevelopersIO saw contains a build number, 27A266a, so a different build should print a different path, which link mode treats as a new version. Run xcode-select --switch to a beta and your next session may be using that beta's skills. If a beta suddenly makes the agent reach for APIs your deployment target doesn't have, check this first.

The "Update marketplace" action skips this plugin. Anthropic's install guide says plugins with a command source are not updated that way, so use the Installed tab or claude plugin update xcode@claude-plugins-official when you want to force it.

Setting CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC skips the background re-run. Some teams set that for privacy or network reasons, and on those machines you need an explicit update after each Xcode upgrade.

What you're granting

Claude Code shows the same warning for every plugin, including this one: Anthropic "does not control what MCP servers, files, or other software are included in plugins and cannot verify that they will work as intended or that they won't change." Being listed in the official catalog tells you who runs the catalog. For a command source it says even less, because the files are produced locally after the listing was reviewed.

Here the code comes from your own Xcode, which you already trust to build your app. The thing to think about is the reach you're handing to an agent. According to the plugin security page, Claude Code's permission rules cover the tool calls Claude makes, including calls to a plugin's MCP tools, while hooks, monitors and server processes run outside the sandbox with your user permissions. So your allow and deny rules still apply when Claude asks Xcode to build or tap, and the script's "Code that runs by itself" line tells you whether your build ships hooks or binaries as well.

Apple says Xcode alerts you when an external agent connects and when it's active. DevelopersIO also notes the agent must be approved on the Xcode side on first use. Baykar, writing about the Xcode 27 betas, reports several details worth reading if you're past the basics:

  • Agent identity comes from the code signature. A wrapper such as timeout xcrun mcpbridge gets approved in place of Claude Code, and unsigned binaries only receive 24-hour grants.
  • A permitted agent can extend its reach by opening a project outside the folders it was granted, so grant repository roots and avoid broad parent directories.
  • The flag --unsafe-always-allow-all-agents lets any process on the Mac drive any reachable project. Keep it off anything that isn't a throwaway build machine.

He also warns that these commands may change between betas, so confirm them against xcrun mcp-server --help on your version.

For an app holding real signing identities or production config, set up a branch you can throw away and keep release signing out of the agent's path. An agent that can build and run your app can also read what's in the project. Think about any API keys committed to a config file before you connect it.

A first session on a real project

Keep the first run read-only and small, so you learn what the tools do on your project before they change anything. Open the project in Xcode, start Claude Code in the repository root and work through these in order.

  1. Ask for a list of the Xcode tools and skills available in this session, and which schemes it can see. If this comes back empty, the problem is the Xcode setting or a closed project.
  2. Ask it to build the main scheme and report warnings without fixing them. Compare the result with a build you run yourself.
  3. Ask for a security build settings review that writes its findings to a file and changes nothing. DevelopersIO's run flagged Enhanced Security being disabled and Pointer Authentication being off, and it wrote a notes file. Read the recommendations before enabling any, since hardening options can affect third-party binaries.
  4. Give it one simulator check with a known answer: launch the app, tap a specific control a set number of times and report the result. Its report is only useful if you know what the correct behavior is. DevelopersIO's test found a real counter bug this way, where the value jumped from 2 to 4 instead of 3.
  5. Only then ask for a small code change, on a branch.

Simulator support has a floor: DevelopersIO reports device-interaction supports iOS, watchOS and tvOS simulators at 27.0 or later. If your test matrix stops at an older runtime, it won't cover those. Baykar also reports that unlabeled controls can stall the agent during simulator automation, much as they stall VoiceOver. An agent that keeps failing to find a button may be telling you about an accessibility gap.

Expect the skills to help most where training data is stale. In DevelopersIO's single comparison, a swipe-to-delete request for an iOS 27 target took 160 lines and 81 seconds without the skill, and 31 lines and 17 seconds with it, because the model otherwise didn't know the current swipeActions behavior. That is one author and one task, so treat it as a reason to run your own comparison.

Teams and CI

On a team, the main risk is a mixed fleet. If you commit the plugin at project scope and one person is still on Xcode 26, the command is likely to fail on their machine and they'll see a plugin error at startup. Agree on the Xcode version first, and list it in your README next to the install line.

Cloud sessions won't help here. Anthropic's install guide says a cloud session doesn't load plugins you installed on your own machine, and the plugin needs a Mac with Xcode in any case. Headless runs with claude -p do load plugins that are already installed, although /plugin itself isn't available there, so install from the shell as a separate step. For a build machine without a window, Baykar's post covers sudo xcrun mcp-server enable and what you give up, including Canvas, the view debugger and some window-related tools.

If your organization has an allowlist for Claude Code plugins, ask for this one by its full ID, and mention that it relies on a command source, since that is the setting your administrator will need to check.

To back out, run claude plugin uninstall xcode@claude-plugins-official --scope local with the scope you used. Your Xcode settings stay as you left them, so set "Allow External Agents to Use Xcode Tools" back to Never if you want that closed too.

What's still unconfirmed

The contents of the generated plugin come from a September write-up on one Xcode build, so yours may differ. Apple's documentation hadn't described this route as of November 8. No Mac was used to prepare this post, so the install flow here is assembled from Anthropic's and Apple's documentation and from those published reports. If claude plugin details xcode disagrees with anything above, believe your own machine.

If you want a working structure around tools like these, Claude Code + Xcode: The Production iOS Workflow Kit is a paid download from this blog's author with AGENTS.md and CLAUDE.md templates, 6 commands, 10 iOS agents, 8 rules and a runnable sample project. It's a separate product from Apple's plugin, and its listing says it was verified with Claude Code 2.1.208 and Xcode 26.2, so expect to adapt it for Xcode 27.

Sources