I Built a dsh-apple-mode Plugin for DeepSeek Harness

iOS developers' AI workflows no longer have to choose between "Xcode's intelligence" and "the agent you're used to."

DeepSeek Harness has finally launched its public beta, and I downloaded it to try it out right away. Honestly, it really surprised me. Its completeness is already very high. Although the UI is still a bit plain, its underlying ability to understand, analyze, and complete tasks has already surpassed Antigravity and is on the same level as Codex and Claude. The latter two are currently more mature in usability and more beginner-friendly. However, for developers, tuning Harness is already a necessary skill. Below, as an iOS developer, I'll share how I tuned DeepSeek Harness and ultimately developed a dsh-apple-mode plugin to better adapt it for iOS/Apple development.

If you do Apple platform development (iOS / macOS / watchOS / visionOS) and are using an agent tool like DeepSeek Harness (DSH for short), the following scenario is definitely familiar to you:

• You want the AI to directly modify an Xcode project, but it can only read the file system and doesn't understand the organization of project.pbxproj;
• You want the AI to follow best practices for SwiftUI / App Intents, but the general model's knowledge always lags behind the new APIs released after WWDC;
• You want the AI to work in a "Swift-first, check-before-writing" manner like Xcode Intelligence, but you have to assemble prompts for each tool yourself.

Since Xcode 26, Apple has built a large number of AI tools directly into Xcode. Using the built-in third-party model plugins directly yields very good results. However, currently, Xcode's AI plugins are only Codex and Claude; Xcode 27 merely added Gemini. For other IDEs/Harnesses, how to fully utilize Xcode's built-in AI capabilities becomes the focus of our tuning.

Xcode 26 actually already gives us these three "raw materials" — mcpbridge (the official MCP tool), xcrun agent skills export (official skills), and the system prompt within the IDEIntelligenceChat framework. What's missing is just a carrier to combine them.

Thus, dsh-apple-mode was born: a plugin that packages "execution capability + knowledge capability + behavioral style" into a DSH "mode." Once installed, you get the complete Xcode AI capability stack within a session.

---

1. Three Raw Materials, Three Different Layers

Before starting, let's first clarify the roles of these three things:

Layer	Capability	Source	Corresponding DSH Mechanism
Execution (Hands)	26 Xcode MCP tools	mcpbridge (Xcode official STDIO bridge)	dsh-mcp-client
Knowledge (Brain)	10 Apple platform skills	Locally exported via xcrun agent skills export	dsh-skill-filesystem
Behavior (Personality)	Xcode Intelligence prompt style	IDEIntelligenceChat.framework	agent preset's persona

MCP tools solve "whether the AI can operate an Xcode project": reading/writing files follows Xcode project organization rather than the file system, changing build settings without touching pbxproj, reading the Issue Navigator, switching schemes / run destinations / test plans, and directly reading/writing String Catalogs.

Skills solve "whether the AI knows the correct approach": swiftui-specialist (SwiftUI best practices), app-intents-specialist (App Intents authoritative guide), audit-xcode-security-settings (build security hardening), adopt-c-bounds-safety (C language bounds safety)... These are authoritative content officially released by Apple, explicitly stating "unconditionally supersedes the model's prior training knowledge," and are lazily loaded on demand, not occupying context.

Prompts solve "how the AI works": Swift-first, tool-assisted reasoning, classifying "explanation vs. modification" before acting — transplanting Xcode Intelligence's working style into DSH sessions.

These three things are complementary, not mutually exclusive. So the plugin's core design decision is: Use DSH's agent preset (mode) mechanism to combine them.

2. Core Design Decision: Why a "Mode" Instead of Global Integration

The most natural composition unit in DSH is the agent preset (mode) — essentially an agent.cordis.yml composition file that can customize persona, mount tools, and select skill sets. Users choose on demand when creating a new session.

Initially, I also considered integrating MCP globally (writing it into the profile's patch), but I was immediately dissuaded by one number: The large schema of 26 tools resident in context costs approximately 6k+ extra tokens per request. If every session carried this schema, it would mean every unrelated task is paying for the Xcode toolset.

Mounting it within a preset is completely different:

• Sessions choosing "Apple Mode" → 26 mcp__xcode__* tools + 10 skills + Xcode Intelligence style persona, full capability set;
• Other sessions → Remain lightweight, zero extra burden.

This is also the practice of DSH's "everything is a plugin, compose on demand" philosophy: tools and behavior follow the mode, not the process.

3. Feature List

26 Xcode MCP Tools (mcp__xcode__*)

Group	Tools
Project Read/Write	XcodeRead XcodeWrite XcodeUpdate XcodeMV XcodeRM XcodeMakeDir
Search	XcodeGlob XcodeGrep XcodeLS
Targets & Build Settings	XcodeNewTarget XcodeListTemplates XcodeListTargets UpdateTargetBuildSetting UpdateFileCompilerFlags
Scheme / Run / Test	XcodeListSchemes XcodeSwitchScheme XcodeListRunDestinations XcodeSwitchRunDestination XcodeListTestPlans XcodeSwitchTestPlan
Diagnostics	XcodeListNavigatorIssues XcodeRefreshCodeIssuesInFile
Localization	StringCatalogRead StringCatalogEdit
Window	XcodeListWindows XcodeGetCurrentFile

A few points worth highlighting individually:

• Changing build settings without touching pbxproj: UpdateTargetBuildSetting / UpdateFileCompilerFlags are the correct approaches officially provided by Xcode. The tool description directly states "do not directly edit project.pbxproj";
• Diagnostics as context: XcodeListNavigatorIssues can get the current issues in the Issue Navigator (including fresh/stale status), so the AI doesn't have to guess when fixing bugs;
• Localization one-stop shop: StringCatalogRead can fetch keys bucketed by translation status (untranslated/needs review/translated), and StringCatalogEdit writes directly.

10 Apple Platform Skills

swiftui-specialist · swiftui-whats-new-27 · app-intents-specialist · app-intents-whats-new-27 · audit-xcode-security-settings · adopt-c-bounds-safety · uikit-app-modernization · modernize-tests · device-interaction · building-document-based-swiftui-applications

A Compliance Design Worth Learning From

The skills are Apple official content (SKILL.md states "published by Apple"). Directly bundling them into a repository for redistribution carries licensing risks, so the repository only contains our own code, configuration, and documentation. Skills are generated locally on the user's machine by install.sh via xcrun agent skills export — ensuring the content is both up-to-date and carries zero distribution risk.

4. Multiple Xcode Versions Coexisting: Choose During Installation

Many developers have both Xcode.app and Xcode-beta.app installed on their machines, and mcpbridge only exists under Contents/Developer/usr/bin in Xcode 26+. The plugin provides a three-level solution:

./install.sh --list-xcodes   # List all Xcodes containing mcpbridge
./install.sh                 # Interactive selection (defaults to xcode-select chosen one)
./install.sh --xcode /Applications/Xcode.app   # Non-interactive specification

The choice during installation is directly rendered into the preset: by default uses xcrun mcpbridge (portable, follows xcode-select); if another Xcode is chosen, the absolute path is written.

Advanced scenario — runtime switching, no reinstall:

./install.sh --runtime-selectable   # Install bin/mcpbridge launcher
DSH_XCODE_DEVELOPER_DIR=/Applications/Xcode-26.2.app/Contents/Developer dsh web

If you want the MCP connection to target a specific running Xcode instance, you can also add env: { MCP_XCODE_PID: '<pid>' } in the preset.

5. Quick Start

git clone https://github.com/jihongboo/dsh-apple-mode.git
cd dsh-apple-mode
./install.sh

The install script does three things: detects and lets you choose an Xcode → installs the Apple Mode preset → locally generates 10 skills.

Usage:

1. Restart dsh (or directly create a new session — presets can only be selected for blank sessions);
2. When creating a session, choose Apple Mode;
3. Start working.

⚠️ Before using MCP tools: Ensure Xcode is launched and the corresponding project is opened, and click "Allow" in the MCP access dialog that pops up in Xcode — otherwise tool calls will be denied. This is likely the easiest pitfall for beginners.

If you want MCP tools in all sessions (without selecting a mode), there's also a global approach:

dsh plugin --profile web add "github:jihongboo/dsh-apple-mode"

6. Some Real-World Usage Scenarios

• Fixing compile errors: Let the AI first XcodeListNavigatorIssues to get the real error list, then XcodeRead to locate, XcodeUpdate to fix, and finally XcodeRefreshCodeIssuesInFile to verify — no copying and pasting error text throughout the entire process;
• SwiftUI new API migration: The swiftui-whats-new-27 skill can handle compile errors like "used before being initialized" caused by @State macrofication after upgrading to the iOS 27 SDK (reordering init is the wrong fix);
• Localization completion: StringCatalogRead pulls untranslated keys, AI batch StringCatalogEdit according to Apple's quotation conventions;
• Security audit: audit-xcode-security-settings skill + UpdateTargetBuildSetting, progressively enabling compile warnings, static analyzer, and Enhanced Security, with decision documentation at each step for rollback;
• Creating a new extension target: XcodeListTemplates to check templates → XcodeNewTarget to create (automatically handling rules like bundle id prefix, embedding in host app, etc.).

7. Boundaries to Note

• Approval boundary: MCP tool calls do not go through DSH's file sandbox; they go through a tool-level approval process — XcodeUpdate / XcodeWrite will directly modify real project files (including project.pbxproj), and you will see the corresponding tool name during approval;
• Build/Run/Test still go through terminal: The MCP toolset is responsible for project surgery and diagnostics; for building, it's recommended to pipe xcodebuild to xcsift for structured output;
• Compatibility: DeepSeek Harness is in developer preview stage, interfaces may change; the plugin itself is content-based (configuration + scripts), not dependent on DSH internal APIs, so upgrade risk is very low.

8. Resource Links

• Repository: https://github.com/jihongboo/dsh-apple-mode (dsh-plugin topic, MIT)
• Release: https://github.com/jihongboo/dsh-apple-mode/releases/tag/v1.0.0
• Inclusion PR: https://github.com/awesome-dsh-plugin/awesome-dsh-plugin/pull/4
• Official DSH: https://github.com/deepseek-ai/deepseek-harness
• Plugin Topic: github.com/topics/dsh-plugin

---

Summary: What dsh-apple-mode does is simple — it takes the three "raw materials" officially provided by Xcode (MCP tools, skills, and Intelligence prompts) and assembles them into an out-of-the-box mode using DSH's preset mechanism. If you can't live without Xcode's intelligence but also want to work within the agent workflow you're familiar with, it's worth a try.