Skip to content
Back to search

xclaude-plugin

iOS development ClaudeCode plugin for mindful token and context usage. Contains modular MCPs that group various Xcode/IDB tools based on your current workflow.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/conorluddy--xclaude-plugin/badge.svg)](/listings/conorluddy--xclaude-plugin)

HTML

<a href="/listings/conorluddy--xclaude-plugin"><img src="/api/listings/conorluddy--xclaude-plugin/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

From GitHub (Recommended)

/plugin marketplace add conorluddy/xclaude-plugin
/plugin install xclaude-plugin

From Local Development

/plugin marketplace add /path/to/xclaude-plugin
/plugin install xclaude-plugin

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 34 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "xclaude-plugin-marketplace",
  3. "owner": {
  4. "name": "Conor Luddy",
  5. "email": "conor@conorluddy.com",
  6. "url": "https://github.com/conorluddy"
  7. },
  8. "metadata": {
  9. "description": "iOS development automation plugin for Claude Code",
  10. "version": "0.4.0"
  11. },
  12. "plugins": [
  13. {
  14. "name": "xclaude-plugin",
  15. "source": "./",
  16. "description": "Modular iOS development automation suite. 8 workflow-specific MCP servers (400-3500 tokens) with 24 tools across Xcode, Simulator, and IDB. Enable only what you need!",
  17. "version": "0.4.0",
  18. "author": {
  19. "name": "Conor Luddy",
  20. "url": "https://github.com/conorluddy"
  21. },
  22. "keywords": [
  23. "xcode",
  24. "ios",
  25. "simulator",
  26. "testing",
  27. "idb",
  28. "accessibility",
  29. "automation"
  30. ],
  31. "strict": true
  32. }
  33. ]
  34. }
README.md · README · 634 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. Note: This was built back when MCPs used to take up a bunch of context even when unused. The idea was that you could quickly toggle modular plugins on and off as you needed them. Since then MCP has evolved to use very little context when not in use - so I'm not maintaining this any more. You can use my `xc-mcp` or `ios-simulator-skill` repos instead to do the same thing.
  2. https://github.com/conorluddy/ios-simulator-skill
  3. https://github.com/conorluddy/xc-mcp
  4. # xClaude Plugin
  5. ```
  6. /plugin marketplace add conorluddy/xclaude-plugin
  7. ```
  8. **Modular iOS development automation for Claude Code**
  9. Build, test, and automate iOS apps through natural conversation with Claude. 8 workflow-specific MCP servers with 24 tools across Xcode, Simulator, and IDB.
  10. **Enable only what you need.** Each MCP is purpose-built for specific workflows, keeping your context window lean. Plus, our tools intelligently encapsulate Xcode output (errors, test results, build logs) so Claude processes structured JSON instead of raw 50+ line logs—saving significant tokens and enabling faster feedback loops.
  11. <img width="1278" height="407" alt="Screenshot 2025-11-08 at 10 44 28" src="https://github.com/user-attachments/assets/ff1c0a09-f29d-4a86-a280-97b3bbc8c635" />
  12. ## Features
  13. ### 🎯 Modular Architecture
  14. - **8 workflow-specific MCP servers** (600-3500 tokens each)
  15. - **Enable only what you need** - Ultra-minimal to full-featured
  16. - **23 shared tools** across Xcode, Simulator, and IDB
  17. - **Single source of truth** - tools defined once, imported by MCPs
  18. ### 🔥 Surgical MCPs (Ultra-Focused)
  19. - **xc-build** (~600 tokens) - Build validation, errors, clean, list schemes
  20. - **xc-launch** (~400 tokens) - Simulator app lifecycle: install and launch
  21. - **xc-interact** (~900 tokens) - Pure UI interaction, no build
  22. ### 📦 Core Workflow MCPs
  23. - **xc-ai-assist** (~1400 tokens) - Build + UI automation + screenshots
  24. - **xc-setup** (~800 tokens) - Environment configuration and validation
  25. - **xc-testing** (~1200 tokens) - Test execution + UI flows
  26. - **xc-meta** (~700 tokens) - Project maintenance and housekeeping
  27. ### 🚀 Full Access
  28. - **xc-all** (~3500 tokens) - All 24 tools for complex workflows
  29. ### 📚 8 Procedural Skills (Loaded On-Demand)
  30. - **xcode-workflows** - Build system guidance and result analysis
  31. - **simulator-workflows** - Device and app lifecycle patterns
  32. - **ui-automation-workflows** - Accessibility-first automation
  33. - **accessibility-testing** - WCAG compliance and quality checks
  34. - **ios-testing-patterns** - Test execution and flaky test detection
  35. - **crash-debugging** - Crash log analysis and symbolication
  36. - **performance-profiling** - Instruments integration
  37. - **state-management** - Cache and configuration management
  38. ## Installation
  39. ### From GitHub (Recommended)
  40. ```bash
  41. /plugin marketplace add conorluddy/xclaude-plugin
  42. /plugin install xclaude-plugin
  43. ```
  44. ### From Local Development
  45. ```bash
  46. /plugin marketplace add /path/to/xclaude-plugin
  47. /plugin install xclaude-plugin
  48. ```
  49. ## First 60 Seconds
  50. Just installed? Enable **xc-build** and **xc-launch** for rapid development:
  51. ```
  52. 1. In Claude settings, enable "xc-build" and "xc-launch" MCPs
  53. 2. Ask Claude: "Build and run MyApp on iPhone 15"
  54. 3. Done! ✨
  55. ```
  56. That's it. **xc-build** + **xc-launch** gives you a composable development loop: build with xc-build, then install & launch with xc-launch. Claude orchestrates the two-step workflow. If you need other workflows (testing, setup, UI automation), see **Choosing the Right MCP** below.
  57. ## Requirements
  58. - macOS 13.0+ or Linux
  59. - Xcode 15.0+ (macOS only, for iOS development)
  60. - Node.js 18+
  61. - Optional: IDB (Facebook iOS Development Bridge) for advanced UI automation
  62. ## Migration Guide (v0.4.0)
  63. If you're upgrading from an earlier version, note these breaking changes:
  64. ### Renamed Server: `xc-build-and-launch` → `xc-launch`
  65. **What changed:**
  66. - Server renamed from **xc-build-and-launch** to **xc-launch** for clarity
  67. - **Removed:** `xcode_build_and_launch` monolithic tool (with `skip_build` flag), plus `xcode_build`, `xcode_clean`, `xcode_list` (moved to xc-build)
  68. - **Now contains:** Only `simulator_install_app` and `simulator_launch_app`
  69. - **Philosophy:** Use **xc-build** + **xc-launch** together for development loop
  70. **Why:** The monolithic `xcode_build_and_launch` tool coupled build, install, and launch into a single operation. The new architecture separates build concerns (xc-build) from simulator lifecycle (xc-launch), enabling:
  71. - Better error recovery (retry individual steps)
  72. - Clearer mental model (build → install → launch)
  73. - No `skip_build` code smell
  74. - Follows Single Responsibility Principle
  75. **Action required:**
  76. 1. Update your `.mcp.json` configuration:
  77. ```diff
  78. - "xc-build-and-launch": {
  79. - "command": "node",
  80. - "args": ["${CLAUDE_PLUGIN_ROOT}/mcp-servers/xc-build-and-launch/dist/index.js"]
  81. + "xc-launch": {
  82. + "command": "node",
  83. + "args": ["${CLAUDE_PLUGIN_ROOT}/mcp-servers/xc-launch/dist/index.js"]
  84. ```
  85. 2. In Claude settings, enable "xc-launch" instead of "xc-build-and-launch"
  86. **Previous versions:**
  87. - `v0.3.0`: `xc-run` → `xc-build-and-launch`
  88. - `v0.3.0`: `xc-compile` → `xc-build`, `xc-hybrid` → `xc-all`
  89. See `.mcp.json.example` for the current configuration.
  90. ## Choosing the Right MCP
  91. ### Enable the Right MCP for Your Task
  92. **IMPORTANT**: Enable **ONE MCP at a time** for optimal token efficiency. Choose based on your current workflow:
  93. ```
  94. ☐ xc-build # Build validation, errors, clean? (~600 tokens)
  95. ☐ xc-launch # Simulator lifecycle: install + launch? (~400 tokens)
  96. ☐ xc-interact # Testing UI with app already built? (~900 tokens)
  97. ☐ xc-ai-assist # AI-driven UI iteration? (~1400 tokens)
  98. ☐ xc-setup # First time setup? (~800 tokens)
  99. ☐ xc-testing # Running test suites? (~1200 tokens)
  100. ☐ xc-meta # Maintenance tasks? (~700 tokens)
  101. ☐ xc-all # Complex workflow needing everything? (~3500 tokens)
  102. 💡 Tip: Enable xc-build + xc-launch together for development loop (~1000 tokens total)
  103. ```
  104. ### Example Workflows
  105. **Scenario 1: Build and fix errors**
  106. ```
  107. Enable: xc-build (~600 tokens)
  108. "Build the project and show me the errors"
  109. → Uses xcode_build with automatic error extraction
  110. → Returns up to 10 errors for quick fixes
  111. → 87% less tokens than old architecture!
  112. ```
  113. **Scenario 2: Rapid development - build and run**
  114. ```
  115. Enable: xc-build + xc-launch (~1000 tokens)
  116. "Build and run MyApp on iPhone 15"
  117. → Claude orchestrates: build (xc-build) → install & launch (xc-launch)
  118. → Composable two-server workflow
  119. → Better error recovery (retry individual steps)
  120. → Perfect for iterative development
  121. ```
  122. **Scenario 3: Testing UI flows (app already built)**
  123. ```
  124. Enable: xc-interact (~900 tokens)
  125. "Tap the Login button, then check if the profile screen appears"
  126. → Queries accessibility tree (3-4x faster than screenshots)
  127. → Taps elements by coordinates
  128. → Validates UI state without rebuilding
  129. ```
  130. **Scenario 4: AI-driven UI iteration**
  131. ```
  132. Enable: xc-ai-assist (~1400 tokens)
  133. "Update the button color to blue, rebuild, and show me a screenshot"
  134. → Modifies code, builds, captures screenshot
  135. → Complete workflow in one MCP
  136. → Includes visual feedback (screenshots)
  137. ```
  138. ## Architecture
  139. ### Modular MCP Design
  140. ```
  141. ┌─────────────────────────────────────────────────────┐
  142. │ Shared Tool Library (24 tools) │
  143. │ ├─ Xcode (6): build, build+run, clean, test, list, version │
  144. │ ├─ Simulator (12): boot, install, screenshot, etc.│
  145. │ └─ IDB (6): describe, tap, input, gesture, etc. │
  146. └─────────────────────────────────────────────────────┘
  147. ↓ Tools imported by MCP servers ↓
  148. ┌─────────────────────────────────────────────────────┐
  149. │ 8 Workflow-Specific MCP Servers │
  150. │ ├─ xc-build: 3 tools (~600 tokens) │
  151. │ ├─ xc-launch: 2 tools (~400 tokens) │
  152. │ ├─ xc-interact: 6 tools (~900 tokens) │
  153. │ ├─ xc-ai-assist: 7 tools (~1400 tokens) │
  154. │ ├─ xc-setup: 5 tools (~800 tokens) │
  155. │ ├─ xc-testing: 6 tools (~1200 tokens) │
  156. │ ├─ xc-meta: 6 tools (~700 tokens) │
  157. │ └─ xc-all: 24 tools (~3500 tokens) │
  158. └─────────────────────────────────────────────────────┘
  159. ```
  160. ### Key Benefits
  161. **For Users:**
  162. - Enable only what you need (300-3500 tokens)
  163. - Clear mental model (workflow-based naming)
  164. - No tool duplication confusion
  165. - Easy to toggle on/off in Claude settings
  166. **For Developers:**
  167. - Single source of truth (shared tools)
  168. - Easy testing (isolated functions)
  169. - Simple maintenance (update once)
  170. - Type-safe throughout (zero `any` usage)
  171. ## MCP Server Reference
  172. ### 🔥 Surgical MCPs
  173. | MCP | Tools | Token Cost | Use When |
  174. | ---------------------- | ----- | ---------- | ------------------------------------------------------ |
  175. | **xc-build** | 3 | ~600 | Build validation with clean/scheme discovery |
  176. | **xc-launch** | 2 | ~400 | Simulator lifecycle: install and launch app |
  177. | **xc-interact** | 6 | ~900 | Testing UI flows with app already built |
  178. ### 📦 Core Workflow MCPs
  179. | MCP | Tools | Token Cost | Use When |
  180. | ---------------- | ----- | ---------- | --------------------------------------------- |
  181. | **xc-ai-assist** | 7 | ~1400 | AI UI iteration with visual feedback |
  182. | **xc-setup** | 5 | ~800 | Initial setup, environment validation |
  183. | **xc-testing** | 6 | ~1200 | Running test suites + UI automation |
  184. | **xc-meta** | 6 | ~700 | Maintenance, housekeeping, environment checks |
  185. ### 🚀 Full Access
  186. | MCP | Tools | Token Cost | Use When |
  187. | --------- | ----- | ---------- | ------------------------------------ |
  188. | **xc-all** | 23 | ~3500 | Complex workflows needing everything |
  189. **Pro tip**: Don't enable multiple MCPs simultaneously - tool duplication will increase token usage! Use xc-all instead for multi-workflow sessions.
  190. ## Cheat Sheet - Which Tools Are in Which MCP?
  191. Quick reference to find which MCP has the tools you need:
  192. ### Xcode Tools
  193. | Tool | xc-build | xc-launch | xc-interact | xc-ai-assist | xc-setup | xc-testing | xc-meta | xc-all |
  194. |------|:--------:|:---------:|:-----------:|:------------:|:--------:|:----------:|:-------:|:------:|
  195. | `xcode_build` | ✅ | | | ✅ | | | | ✅ |
  196. | `xcode_build_and_launch` | | | | | | | | ✅ |
  197. | `xcode_clean` | ✅ | | | | | | ✅ | ✅ |
  198. | `xcode_test` | | | | | | ✅ | | ✅ |
  199. | `xcode_list` | ✅ | | | | | | ✅ | ✅ |
  200. | `xcode_version` | | | | | ✅ | | ✅ | ✅ |
  201. ### Simulator Tools
  202. | Tool | xc-build | xc-launch | xc-interact | xc-ai-assist | xc-setup | xc-testing | xc-meta | xc-all |
  203. |------|:--------:|:---------:|:-----------:|:------------:|:--------:|:----------:|:-------:|:------:|
  204. | `simulator_list` | | | | | ✅ | | | ✅ |
  205. | `simulator_boot` | | | | | ✅ | | | ✅ |
  206. | `simulator_shutdown` | | | | | | | ✅ | ✅ |
  207. | `simulator_create` | | | | | ✅ | | | ✅ |
  208. | `simulator_delete` | | | | | | | ✅ | ✅ |
  209. | `simulator_install_app` | | ✅ | | | | | | ✅ |
  210. | `simulator_launch_app` | | ✅ | | | | | | ✅ |
  211. | `simulator_terminate_app` | | | | | | | | ✅ |
  212. | `simulator_screenshot` | | | | ✅ | | ✅ | | ✅ |
  213. | `simulator_openurl` | | | | | | | | ✅ |
  214. | `simulator_get_app_container` | | | | | | | | ✅ |
  215. | `simulator_health_check` | | | | | ✅ | | ✅ | ✅ |
  216. ### IDB Tools
  217. | Tool | xc-build | xc-launch | xc-interact | xc-ai-assist | xc-setup | xc-testing | xc-meta | xc-all |
  218. |------|:--------:|:---------:|:-----------:|:------------:|:--------:|:----------:|:-------:|:------:|
  219. | `idb_describe` | | | ✅ | ✅ | | ✅ | | ✅ |
  220. | `idb_tap` | | | ✅ | ✅ | | ✅ | | ✅ |
  221. | `idb_input` | | | ✅ | ✅ | | ✅ | | ✅ |
  222. | `idb_gesture` | | | ✅ | | | ✅ | | ✅ |
  223. | `idb_find_element` | | | ✅ | ✅ | | | | ✅ |
  224. | `idb_check_quality` | | | ✅ | ✅ | | | | ✅ |
  225. ## Tool Library (24 Total)
  226. ### Xcode Tools (6)
  227. - `xcode_build` - Build with automatic error extraction
  228. - `xcode_build_and_launch` - Build, install, and launch on simulator
  229. - `xcode_clean` - Clean build artifacts
  230. - `xcode_test` - Run XCTest suites
  231. - `xcode_list` - List schemes/targets
  232. - `xcode_version` - Check Xcode installation
  233. ### Simulator Tools (12)
  234. - `simulator_list` - Enumerate simulators
  235. - `simulator_boot` - Boot device
  236. - `simulator_shutdown` - Shutdown device
  237. - `simulator_create` - Create new simulator
  238. - `simulator_delete` - Delete simulator
  239. - `simulator_install_app` - Install app
  240. - `simulator_launch_app` - Launch app
  241. - `simulator_terminate_app` - Terminate app
  242. - `simulator_screenshot` - Capture screenshot
  243. - `simulator_openurl` - Open URL/deep link
  244. - `simulator_get_app_container` - Get app container path
  245. - `simulator_health_check` - Validate environment
  246. ### IDB Tools (6)
  247. - `idb_describe` - Query accessibility tree (accessibility-first!)
  248. - `idb_tap` - Tap coordinates
  249. - `idb_input` - Type text or press keys
  250. - `idb_gesture` - Swipes and hardware buttons
  251. - `idb_find_element` - Search by label (semantic)
  252. - `idb_check_quality` - Assess accessibility data richness
  253. ## Configuring Your Project
  254. Add this section to your project's `.claude/CLAUDE.md` file. This guides Claude on when and why to use the xclaude-plugin tools instead of directly calling Xcode or shell commands:
  255. ```markdown
  256. ## xclaude-plugin: Why and When to Use These Tools
  257. The xclaude-plugin provides 8 modular MCPs with 24 specialized iOS tools. **Always prefer these over raw `xcodebuild` or shell commands** for iOS development tasks. Here's why:
  258. ### Why These Tools Trump Raw Commands
  259. | Task | Direct Bash | xclaude-plugin | Why Plugin Wins |
  260. | -------------------- | -------------------------------------------------------------- | -------------------------------- | ------------------------------------------------------------------------- |
  261. | Build + get errors | `xcodebuild -scheme Foo 2>&1` (50+ lines of parsing) | `xcode_build` tool | Auto-extracts up to 10 errors, structured JSON, 87% fewer tokens |
  262. | Test suite execution | `xcodebuild test` + manual parsing | `xcode_test` tool | Parses results, reports failures, timing, code coverage |
  263. | Simulator screenshot | `xcrun simctl io booted screenshot /tmp/x.png` + file handling | `simulator_screenshot` tool | Auto-saves, encoded output, accessible in response |
  264. | UI automation | Manual coordinate finding + shell taps | `idb_describe` + `idb_tap` tools | Queries accessibility tree (120ms), semantic element finding, 3-4x faster |
  265. | App installation | `xcrun simctl install booted App.app` | `simulator_install_app` tool | Builds, finds app, installs, validates—one command |
  266. ### When to Use Each MCP
  267. **Use `xc-build`** (~600 tokens) when:
  268. - Building and fixing errors
  269. - Need to clean build artifacts
  270. - Discovering schemes/targets in project
  271. - Build validation and configuration
  272. **Use `xc-launch`** (~400 tokens) when:
  273. - Installing and launching an app on the simulator
  274. **Use `xc-interact`** (~900 tokens) when:
  275. - Testing UI flows with app already built
  276. - Automating screen validation without code changes
  277. - Need accessibility-first element querying
  278. **Use `xc-ai-assist`** (~1400 tokens) when:
  279. - Iterating on UI with live feedback (code change → screenshot)
  280. - Need visual validation of changes
  281. - Combining code modification with testing
  282. **Use `xc-testing`** (~1200 tokens) when:
  283. - Running test suites and analyzing results
  284. - Need both unit tests and UI automation
  285. - Debugging test failures
  286. **Use `xc-setup`** (~800 tokens) when:
  287. - First-time environment validation
  288. - Checking Xcode/simulator health
  289. - Discovering project structure (schemes, targets)
  290. **Use `xc-meta`** (~700 tokens) when:
  291. - Maintenance tasks (clearing derived data, managing simulators)
  292. - Non-coding iOS project operations
  293. - Environment housekeeping
  294. **Use `xc-all`** (~3500 tokens) when:
  295. - Complex workflows requiring multiple tool categories
  296. - Don't know which single MCP fits the task
  297. - Need flexibility to pivot between workflows
  298. ### Critical: Prefer Plugin Tools Over Bash
  299. When you encounter a task that could use either approach, **always choose the plugin tool**.
  300. **Don't do this:**
  301. # Manual build parsing
  302. > `xcodebuild -scheme MyApp 2>&1 | grep -A5 "error:" | sed ...`
  303. **Do this instead:** Use the `xcode_build` tool from `xc-build` MCP.
  304. ---
  305. **Don't do this:**
  306. # Manual screenshot saving
  307. > `xcrun simctl io booted screenshot /tmp/screenshot.png`
  308. > `cat /tmp/screenshot.png | base64`
  309. **Do this instead:** Use the `simulator_screenshot` tool from `xc-interact` MCP.
  310. ---
  311. **Don't do this:**
  312. # Finding UI elements by trial and error
  313. > `xcrun simctl spawn booted launchctl list | grep bundleid`
  314. **Do this instead:** Use `idb_describe` tool to query accessibility tree, then `idb_tap` to interact.
  315. ### When Bash IS Still Appropriate
  316. Use Bash for tasks outside iOS development:
  317. - File operations: `mkdir`, `cp`, `rm`, `ls`
  318. - Version control: `git status`, `git diff`, `git commit`
  319. - General scripting: `jq`, `sed`, `awk`
  320. - Environment setup: `npm install`, `brew install`
  321. **Never use Bash for iOS-specific tasks** when a plugin tool exists.
  322. ```
  323. ## Simulator Configuration
  324. xclaude-plugin automatically tracks your simulator usage and supports configuration files for default simulators.
  325. ### Config File Locations
  326. **Project-level** (recommended for team consistency):
  327. ```bash
  328. # .xcplugin in your project root
  329. {
  330. "defaultSimulator": "platform=iOS Simulator,name=iPhone 15",
  331. "maxRecentHistory": 10
  332. }
  333. ```
  334. **User-level** (personal defaults across all projects):
  335. ```bash
  336. # ~/.xcplugin/config.json
  337. {
  338. "defaultSimulator": "platform=iOS Simulator,name=iPhone 15 Pro",
  339. "maxRecentHistory": 10
  340. }
  341. ```
  342. **Precedence**: Project config overrides user config.
  343. ### How It Works
  344. 1. **Auto-resolution**: Partial destinations like `"platform=iOS Simulator,name=iPhone 15"` automatically resolve to the latest OS version available
  345. 2. **Usage tracking**: Every build/test automatically tracks which simulators you use
  346. 3. **Smart defaults**: When no config exists, the plugin remembers your most recent simulator
  347. ### Destination Format
  348. The `xcode_build` and `xcode_test` tools accept three destination formats:
  349. ```bash
  350. # 1. Auto-resolve (recommended) - finds latest OS automatically
  351. "platform=iOS Simulator,name=iPhone 15"
  352. # 2. Explicit - specify exact OS version
  353. "platform=iOS Simulator,name=iPhone 15,OS=18.0"
  354. # 3. UDID - direct device identifier
  355. "id=ABC-123-DEF-456"
  356. ```
  357. ### Quick Setup
  358. 1. **Create a config file** (choose one):
  359. ```bash
  360. # Project-level
  361. echo '{"defaultSimulator": "platform=iOS Simulator,name=iPhone 15"}' > .xcplugin
  362. # User-level
  363. mkdir -p ~/.xcplugin
  364. echo '{"defaultSimulator": "platform=iOS Simulator,name=iPhone 15"}' > ~/.xcplugin/config.json
  365. ```
  366. 2. **Find your available simulators**:
  367. ```bash
  368. xcrun simctl list devices available
  369. ```
  370. 3. **Use the `simulator_list` tool** to see your devices:
  371. ```
  372. Ask Claude: "Show me available simulators"
  373. ```
  374. ### Example Config
  375. See `.xcplugin.example` in the plugin directory for a complete example.
  376. ## Enable Minimal MCPs for Token Efficiency
  377. - **Token efficiency**: xc-build (~600 tokens) is 83% cheaper than xc-all (3500 tokens)
  378. - **Mental clarity**: Focused tools per workflow phase
  379. - **Composable workflows**: Enable xc-build + xc-launch together (~1000 tokens) for development loop
  380. **Guidelines:**
  381. - **Single workflow**: Enable one focused MCP (e.g., xc-interact for UI testing only)
  382. - **Development loop**: Enable xc-build + xc-launch together for build → install → launch
  383. - **Complex workflows**: Enable xc-all when you need multiple capabilities simultaneously
  384. ## Development
  385. ### Building from Source
  386. ```bash
  387. # Clone repository
  388. git clone https://github.com/conorluddy/xclaude-plugin.git
  389. cd xclaude-plugin
  390. # Install dependencies
  391. npm install
  392. # Build MCP server
  393. npm run build
  394. # Test locally
  395. /plugin marketplace add /path/to/xclaude-plugin
  396. /plugin install xclaude-plugin
  397. ```
  398. ### Project Structure
  399. ```
  400. xclaude-plugin/
  401. ├── .claude-plugin/
  402. │ ├── plugin.json # Plugin manifest (8 MCP servers)
  403. │ └── marketplace.json # Marketplace configuration
  404. ├── mcp-servers/ # 8 modular MCP servers
  405. │ ├── shared/ # Shared tool library (24 tools)
  406. │ │ ├── tools/ # Tool implementations
  407. │ │ ├── types/ # Shared type definitions
  408. │ │ └── utils/ # Command execution utilities
  409. │ ├── xc-build/ # MCP 1: Build validation
  410. │ ├── xc-launch/ # MCP 2: Simulator lifecycle (install + launch)
  411. │ ├── xc-interact/ # MCP 3: Pure UI interaction
  412. │ ├── xc-ai-assist/ # MCP 4: AI UI automation
  413. │ ├── xc-setup/ # MCP 5: Environment setup
  414. │ ├── xc-testing/ # MCP 6: Test execution
  415. │ ├── xc-meta/ # MCP 7: Maintenance
  416. │ └── xc-all/ # MCP 8: Full toolkit
  417. ├── skills/ # 8 Skills (markdown + YAML)
  418. │ ├── xcode-workflows/
  419. │ ├── simulator-workflows/
  420. │ ├── ui-automation-workflows/
  421. │ ├── accessibility-testing/
  422. │ ├── ios-testing-patterns/
  423. │ ├── crash-debugging/
  424. │ ├── performance-profiling/
  425. │ └── state-management/
  426. └── README.md
  427. ```
  428. ## Design Philosophy
  429. ### Modular Token Efficiency
  430. Enable only what you need. Ultra-minimal MCPs (300 tokens) for focused tasks, comprehensive MCPs (3500 tokens) for complex workflows. 87% token reduction for surgical operations.
  431. ### Accessibility-First UI Automation
  432. Query accessibility tree (120ms, ~50 tokens) before screenshots (2000ms, ~170 tokens). 3-4x faster, 80% cheaper, more reliable across theme changes.
  433. ### Single Source of Truth
  434. 24 tools defined once in shared library, imported by 8 MCPs. Update once, benefit everywhere. Type-safe with zero `any` usage.
  435. ### Workflow-Based Organization
  436. MCPs named by developer workflow phase, not technology domain. xc-build for build validation, xc-setup for environment, xc-all for complex sessions.
  437. ## Contributing
  438. I appreciate contributions, but please note that this repo and my other public repos are far down in the priority queue of what I'm working on, so I'll be slow to review anything. Your best bet is really just to fork the repo and customise it to your own needs.
  439. ## License
  440. MIT License - See [LICENSE](LICENSE) for details
  441. ## Support
  442. - 🐛 [Report issues](https://github.com/conorluddy/xclaude-plugin/issues)
  443. - 💬 [Discussions](https://github.com/conorluddy/xclaude-plugin/discussions)
  444. - 📖 [Documentation](https://github.com/conorluddy/xclaude-plugin/wiki)
  445. ---
  446. **Complete iOS development automation for Claude Code** 🚀

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.