communication MCP Server
AI agent steering for Apple (Swift 6.4 / SwiftUI / visionOS / Foundation Models) and Android (Kotlin / Compose / Gradle / Gemini Nano). Rules + skills + MCP for code, a11y, localization, TestFlight/Play. One install.sh detects your stack, installs the right per-platform rules, and keeps them current for Claude/Copilot/Cursor/Gemini/Codex/Kiro.
Discovered via github-topic:mcp and last synced 3mo ago.
Install instructions not detected yet
Check the source repository for the latest setup steps.
`.claude/rules/`, `.claude/skills/`, `.claude/settings.json`, `CLAUDE.md`
Prompt
gemini
<csv>` — **default `recommended`** is a curated subset for most apps (now includes `linting`); `all` adds specialized opt-ins (`persistence`, `ai`, `migration`, `shrinking`, `spatial`, `deployment`); custom CSVs like `core,testing,docs` give fine-grained control - `--list` previews the catalog with one-line descriptions + category tags - `--list --json` emits the same catalog as machine-readable JSON (used by the MCP server) - `--list-mcps` lists available MCP-server recipes (name, platform, description, homepage) - `--with-mcps <csv>` writes one `mcpServers.<name>` entry per recipe into `.claude/settings.local.json`. Existing entries are never overwritten. Setup notes (auth, env vars) print after install. See [`mcp-recipes/`](mcp-recipes/) for the available recipes. - `--agents <csv>` picks which AI agents to install for. Default `claude`; additive options: `copilot` (writes `.github/copilot-instructions.md`), `cursor` (writes `.cursor/rules/*.mdc`), `gemini` (writes `GEMINI.md`), `codex` (writes `AGENTS.md`), `kiro` (writes `.kiro/steering/*.md`), or `all`. Same rule content, per-agent file shape. Skills are Claude-only. - `--dry-run` shows what an install would do without writing any files - `--upgrade` prints a per-file plan of what would change if you re-installed today — classified as up-to-date / safe update / local-edits / conflict / orphan / addition / out-of-scope / rename. Add `--apply` to execute the plan; `--force-conflicts` to overwrite locally-edited files where the bundle also changed; `--prune` to delete orphans + out-of-scope files; `--migrate-manifest` to bring a v1 manifest forward. The header prints a GitHub compare URL when commits differ. See [Upgrading an existing install](#upgrading-an-existing-install). - `--uninstall` reverses install: deletes every tracked file whose current hash matches what was installed (locally-edited files kept unless `--force-conflicts`; `CLAUDE.md` / `settings.json` kept unless `--purge`). MCP entries are removed if unchanged, unless `--keep-mcps`. Strips the `.gitignore` block and the manifest itself. See [Removing the install](#removing-the-install). - `--help` documents every flag and enumerates all 16 categories - Every install writes a manifest at `.claude/.appbootstrap-manifest.json` (schema v2 — records per-file SHA-256 hashes so `--upgrade` can diff 3-way: installed vs. current disk vs. bundle) - **Three starter `CLAUDE.md` templates** — `templates/CLAUDE.template.apple.md`, `templates/CLAUDE.template.android.md`, `templates/CLAUDE.template.md` (cross-platform). The installer picks the right one based on `--platform`. - **`templates/Package.template.swift`** — starter Swift Package Manager manifest with a `makeTargets(name:dependencies:hasTests:hasResources:testDependencies:testResources:)` helper. Adding a new module is a two-line change: one line in `products:` and one `+ makeTargets(...)` block in `targets:`. Copy it into a new SPM package as `Package.swift` and fill in the placeholders. </details> <details> <summary><strong>Recommended companion MCP tooling</strong> (optional — click to expand)</summary> #### MCP servers for the Apple side - **Xcode 27 native MCP + agent platform** *(WWDC 2026)* — Apple massively expanded the in-Xcode agent story (building on the Xcode 26.3 `mcpbridge` foundation). The native **Xcode MCP server** now adds debug tools (run state, debugger console, schemes, destinations, build settings, entitlements, `Info.plist`), a **Preview Snapshot** tool, simulator control (boot/install/launch, synthesize touches, screenshots), and access to project insights (crashes, hangs, energy). **LLDB ships its own `lldb-mcp`** server ([docs](https://lldb.llvm.org/use/mcp.html)). Most relevant to *this* bundle: Xcode 27 gains **agent plug-ins** — bundling **skills, MCP servers, ACP (Agent Client Protocol) configurations, and slash commands** — plus Apple-built specialists (localization, accessibility, UIKit resizing) and a security layer governing agent filesystem access. First-party, no separate install. See Apple's [Giving agentic coding tools access to Xcode](https://developer.apple.com/documentation/xcode/giving-agentic-coding-tools-access-to-xcode). - **[XcodeBuildMCP](https://github.com/cameroncooke/XcodeBuildMCP)** — community MCP server that lets any agent drive Xcode: build schemes, run simulators, capture logs. Still useful alongside the native server — it leans into richer test/simulator tooling and works from agents outside Xcode. Especially valuable for legacy / mixed-language Apple codebases and for CI-style automation. #### MCP servers for the Android side - **[Android Studio's built-in MCP support](https://developer.android.com/studio/gemini/add-mcp-server)** — Google ships first-party MCP integration in Android Studio. Hook any MCP server (including this repo's, see below) directly into Studio's agent. - **[`android-mcp-server`](https://github.com/minhalvp/android-mcp-server)** — community MCP server that gives agents control over Android devices and emulators via ADB. The Android-side parallel to XcodeBuildMCP's simulator work. #### Cross-platform / shared - **[Firebase MCP](https://github.com/firebase/firebase-tools/tree/main/src/mcp)** — **first-party from Google.** Lives in `firebase-tools`. Covers Crashlytics, Remote Config, App Hosting, Realtime DB, and Cloud Functions logs. Crashlytics surface is marked experimental. - **[Sentry MCP](https://docs.sentry.io/product/sentry-mcp/)** — **first-party, hosted by Sentry** at `mcp.sentry.dev/mcp`. Streamable HTTP with OAuth — zero install for sentry.io users. Exposes issues, errors, projects, and Seer analysis. **See also** (specialized; add when the use case fits): - **[`ios-simulator-mcp`](https://github.com/joshuayoes/ios-simulator-mcp)** — npm-installable, iOS-Simulator-only (screenshots, UI hierarchy, tap/swipe). Lighter than XcodeBuildMCP if Simulator control is all you need. - **[Mobile MCP (`mobile-next/mobile-mcp`)](https://mcpservers.org/servers/mobile-next/mobile-mcp)** — cross-platform iOS + Android automation via accessibility snapshots + coordinate taps. QA-style workflows that span both platforms. - **[`kotlin-mcp-server`](https://github.com/normaltusker/kotlin-mcp-server)** — heavier-touch Android dev workflow MCP: Gradle, ktlint, Lint, Room / Retrofit / Compose scaffolding via AI prompts. - **[Figma MCP](https://help.figma.com/hc/en-us/articles/32132100833559-Guide-to-the-Figma-MCP-server)** — first-party Figma server for design → code workflow. Mobile-relevant when your design source is Figma; not mobile-specific. - **App Store Connect** and **Google Play Console** MCPs exist but the ecosystem is still consolidating around a winner — multiple competing community implementations. Worth watching but no recommendation yet. - **Linear / Jira / Atlassian** MCPs (Atlassian's is GA Feb 2026, Linear's is first-party) are excellent but cover generic project-management concerns, not mobile-app-specific work — they belong in your generic MCP setup, not this list. #### Cross-tool rule sync - **Multi-agent support** — pass `--agents copilot,cursor,gemini,codex,kiro` to `install.sh` and the bundle writes the right file shape for each agent (in addition to or instead of Claude). For agents not in that built-in set (Cline, Goose, Roo, Windsurf, etc.), point a sync tool at `.claude/`. See [Using with non-Claude AI agents](#using-with-non-claude-ai-agents). </details> ## Getting started The installer takes a **command verb** — `install` (the default, so it can be omitted), `upgrade`, `uninstall`, `list`, `list-mcps`, or `setup`. Three ways in, depending on where you are. Not sure which? Run **`setup`** and it figures it out: ```bash # Guided, prompt-driven — detects create vs. adopt vs. update and walks you # through platform, features, agents, and MCP recipes with sensible defaults. /path/to/AppBootstrapAI/install.sh setup ``` > **Verbs and flags are interchangeable.** Every verb has a legacy flag alias — > `upgrade` == `--upgrade`, `uninstall` == `--uninstall`, `list` == `--list`, > `setup` == `-i` / `--interactive`. Existing scripts that use the flag form keep > working unchanged. ### 1. New project (green-field) Create the directory, `git init` it, and install the bundle in one step: ```bash /path/to/AppBootstrapAI/install.sh install ~/Projects/MyNewApp --new --platform apple ``` `--new` makes the target dir (and parents) and initializes a fresh git repo, then installs. It's light scaffolding — it does **not** generate an Xcode or Gradle project; create that with Xcode / Android Studio, then commit. ### 2. Existing project (adopt) Point the installer at your repo root. Platform auto-detects from the files already there (`install` is the default verb, so you can omit it): ```bash cd /path/to/your/app /path/to/AppBootstrapAI/install.sh . ``` Nothing you've authored gets overwritten — an existing `CLAUDE.md`, `settings.json`, or agent file is left alone and the installer prints what it skipped so you can merge by hand. ### 3. Update an existing install (stay current with upstream) Once a repo is managed (it has a `.claude/.appbootstrap-manifest.json`), use `upgrade` — never a plain re-install: ```bash /path/to/AppBootstrapAI/install.sh upgrade . # plan-only preview /path/to/AppBootstrapAI/install.sh upgrade . --apply # execute the plan ``` `upgrade` runs a 3-way diff (what was installed vs. your current files vs. the latest bundle) so your local edits are preserved. A plain `install` over a managed repo is **refused** with guidance to use `upgrade` — that guard stops a re-install from silently resetting the manifest baseline. If you genuinely want to re-install over a managed target, pass `--force`. ## Quick start The full flag reference. Examples below use the bare/`install` form; prefix any of them with a verb (`install` / `upgrade` / `uninstall` / `list` / `setup`) or use the equivalent `--flag` — they're interchangeable. From the root of a new app repo: ```bash # Zero-flag install — installer auto-detects platform from the target dir. # Package.swift / *.xcodeproj → apple; build.gradle* / gradlew → android; # both present → both; neither (fresh repo) → falls back to both. # The header prints which signals matched so you can verify. /path/to/AppBootstrapAI/install.sh . # Explicit platform always wins over detection /path/to/AppBootstrapAI/install.sh . --platform apple /path/to/AppBootstrapAI/install.sh . --platform android /path/to/AppBootstrapAI/install.sh . --platform both # Opt in to the FULL bundle including specialized opt-ins # (persistence/Core Data, ai/Foundation Models, migration, shrinking) /path/to/AppBootstrapAI/install.sh . --platform both --features all # Pick specific feature categories /path/to/AppBootstrapAI/install.sh . --platform apple --features core,testing,docs # Apple legacy project — Objective-C only /path/to/AppBootstrapAI/install.sh . --platform apple --apple-language objc # Apple mixed-language — Swift + ObjC /path/to/AppBootstrapAI/install.sh . --platform apple --apple-language both # Preview what any flag combo will install (no files written, with category tags) /path/to/AppBootstrapAI/install.sh --list --platform android --features all # Same catalog as JSON (for automation / the MCP server) /path/to/AppBootstrapAI/install.sh --list --json --platform apple --features all # Show what an install would do without actually writing files /path/to/AppBootstrapAI/install.sh /target --platform apple --features all --dry-run # Compose recommended + specific opt-ins (instead of writing the CSV by hand) /path/to/AppBootstrapAI/install.sh . --platform apple --features recommended,ai,persistence # visionOS app — pull in the visionOS rule (scene types, immersion styles, # RealityKit conventions, head-mounted-display accessibility, USDZ pipeline). # Either name the platform, or add the spatial feature — they're equivalent: /path/to/AppBootstrapAI/install.sh . --platform apple --apple-platforms ios,visionos /path/to/AppBootstrapAI/install.sh . --platform apple --features recommended,spatial # Target specific Apple platforms (default is everything except visionOS) /path/to/AppBootstrapAI/install.sh . --platform apple --apple-platforms ios,macos # Shipping to testers — add the deployment category for TestFlight (Apple) + # Play beta (Android): versioning, signing, CI patterns, common gotchas /path/to/AppBootstrapAI/install.sh . --features recommended,deployment # Bootstrap + wire in MCP servers at the same time # (writes one mcpServers entry per recipe into .claude/settings.local.json) /path/to/AppBootstrapAI/install.sh . --platform apple --with-mcps xcodebuildmcp,sentry # Browse available MCP recipes (see what --with-mcps can install) /path/to/AppBootstrapAI/install.sh --list-mcps # Install for a non-Claude agent — writes that agent's native file shape /path/to/AppBootstrapAI/install.sh . --agents copilot # → .github/copilot-instructions.md /path/to/AppBootstrapAI/install.sh . --agents cursor # → .cursor/rules/*.mdc /path/to/AppBootstrapAI/install.sh . --agents gemini # → GEMINI.md /path/to/AppBootstrapAI/install.sh . --agents codex # → AGENTS.md /path/to/AppBootstrapAI/install.sh . --agents kiro # → .kiro/steering/*.md # Mixed team — install for several agents in one run /path/to/AppBootstrapAI/install.sh . --agents claude,copilot,cursor # Everything (claude + copilot + cursor + gemini + codex) /path/to/AppBootstrapAI/install.sh . --agents all # Existing install? Diff and apply updates without losing local edits /path/to/AppBootstrapAI/install.sh . --upgrade # plan-only preview /path/to/AppBootstrapAI/install.sh . --upgrade --apply # execute the plan # Full help — documents --features categories, --with-mcps recipes, --agents tokens /path/to/AppBootstrapAI/install.sh --help ``` Every real install writes a manifest at `.claude/.appbootstrap-manifest.json` listing every file that was installed plus the flags used. The manifest is what powers `--upgrade`'s 3-way diff against future bundle versions. **The default `--features recommended` set** covers what most apps need on day one: `core` (project docs) + `concurrency` + `ui` + `testing` + `docs` (code documentation) + `error-handling` + `packaging` + `logging` + `localization` + `linting` (SwiftLint+formatter / ktlint+detekt+Android Lint). Specialized opt-ins not in `recommended`: `persistence` (Core Data / SwiftData), `ai` (Apple Foundation Models + Android Gemini Nano / Firebase AI Logic), `migration` (XML → Compose), `shrinking` (R8/ProGuard), `spatial` (visionOS scene types, immersion styles, spatial gestures, RealityKit conventions), `deployment` (TestFlight + Play beta tracks — versioning, signing, CI patterns, common gotchas). **The default `--agents claude` set** writes the native Claude Code layout. Pass `--agents copilot
`GEMINI.md`
`.github/copilot-instructions.md`
File(s) written
`cursor`
`AGENTS.md`
Approach
both` always wins. Use this when bootstrapping a fresh empty repo (otherwise the fallback is `both`, which is too broad if you know it's iOS-only). - **Stick to `--features recommended` (default).** Specialized categories — `persistence` (Core Data), `ai` (Foundation Models), `migration` (XML→Compose), `shrinking` (R8) — only load when you opt in. If your app doesn't use Core Data, the `coredata-swift6-pro` skill is wasted catalog space. - **Pure-Swift project? Keep `--apple-language swift` (the default).** That skips the two `apple-objc-*` rules. Only switch to `both` if you have genuine `.h`/`.m`/`.mm` files; switch to `objc` for legacy ObjC-only codebases. - **Not a visionOS app? The default already excludes it.** `--apple-platforms` defaults to `ios,macos,tvos,watchos` — so the visionOS rule (the one sub-platform-specific Apple rule) stays out unless you name `visionos` (or pass `--features …,spatial`). Building for visionOS? `--apple-platforms ios,visionos` pulls it in. Every *other* Apple rule is universal across iOS/macOS/tvOS/watchOS, so there's nothing else to trim per-platform — Apple installs are already lean by design. - **`--with-mcps` only what you'll use this week.** Each MCP entry adds tool metadata to the agent's catalog. If you're not actively using Firebase MCP, don't install it. When you over-broaden any of these, `install.sh` prints a "Token-saving tips" block at the end suggesting the tighter flag. That's the install-time feedback loop. ### During development - **Be specific in prompts.** *"Review `Sources/Networking/Client.swift`"* loads one file. *"Review the codebase"* invites the agent to search the whole tree. The first prompt is usually 10–100x cheaper. - **Invoke skills by name.** *"Use `swift-concurrency-pro` to review X.swift"* loads that one skill's references. Asking general questions can trigger speculative skill loads — sometimes several at once. - **Truncate build-log paste-ins.** When a build fails, paste the failing 20–50 lines plus the function signature, not 500 lines of unrelated warnings. (Documented in detail in `apple-objc-best-practices.md` for the mixed-language case; same principle for any language.) - **One skill at a time.** Running multiple deep-review skills back-to-back in the same turn forces the agent to hold all of their reference docs in context simultaneously. Sequence them across turns. ### Long-running - **Keep your project's `CLAUDE.md` focused.** It loads on every session. Stale sections and aspirational content are pure context tax — prune ruthlessly. - **Periodically run `./install.sh --list`** to see what's installed vs. what's available. If you've stopped using a category (e.g., you've fully migrated off XML→Compose), re-run install without it to drop the `migration` rules and `xml-to-compose-migration-pro` skill. - **Use the MCP server for agent-driven installs.** If you're asking an agent to bootstrap a new repo, the [MCP server](mcp-server/README.md) returns structured JSON (`list_categories`, `list_rules`, `list_skills`) — cheaper for the LLM to consume than parsing the catalog's plain-text format. ### What this won't save To set expectations honestly: scoping the install down won't dramatically cut your bill if your prompts are already loose. Rules with `globs:` only attach to context when matching files are in the conversation — Android rules in an iOS-only repo are effectively dormant whether or not they're installed. The bigger wins come from prompt discipline and explicit skill invocation, not from install-flag micro-optimization. ## Using with non-Claude AI agents `install.sh` has a `--agents` flag for picking which agent(s) you want — additive, default `claude`. The bundle generates the right file shape for each agent from the same source `.claude/rules/`. ```bash # Default — Claude Code only (today's behavior) /path/to/AppBootstrapAI/install.sh . # GitHub Copilot — writes .github/copilot-instructions.md (concat of in-scope rules) /path/to/AppBootstrapAI/install.sh . --agents copilot # Cursor — writes per-rule .cursor/rules/<name>.mdc files /path/to/AppBootstrapAI/install.sh . --agents cursor # Amazon Kiro — writes per-rule .kiro/steering/<name>.md files /path/to/AppBootstrapAI/install.sh . --agents kiro # Mixed team — install for Claude + Copilot + Cursor in one go /path/to/AppBootstrapAI/install.sh . --agents claude,copilot,cursor # Everything — claude + copilot + cursor + gemini + codex + kiro /path/to/AppBootstrapAI/install.sh . --agents all ``` Per-agent file shape:
`.kiro/steering/<name>.md`
What's inside
Send messages and upload files to Slack channels using the `slack` CLI. Supports direct messages, channel posts, file uploads, and thread replies.
Bidirectional Telegram bridge — talk to Claude from your phone. Built into OpenPaw.
Discover agents across local node and mesh peers at runtime — their roles, handles, and how to communicate with or delegate to them.
Apply data visualization and storytelling principles from Storytelling with Data by Cole Nussbaumer Knaflic. Covers choosing effective visuals (line, bar, table, scatterplot), eliminating clutter (Gestalt principles, data-ink ratio), focusing attention (preattentive attributes, strategic color), thinking like a designer (affordances, alignment, white space), and narrative structure (three-act story, horizontal/vertical logic, Big Idea). Trigger on "data visualization", "chart design", "dashboard design", "data storytelling", "presentation chart", "declutter chart", "bar chart", "line chart", "data narrative", "slide deck data", "chart review", "viz critique", "storytelling with data".
🔬 A curated collection of 23,000+ agent skills for empirical research across 8 social science disciplines. | 精选 23,000+ AI Agent 技能库，覆盖8大社会科学学科的实证研究。CoPaper.AI 20分钟完成一篇可复现的规范实证论文，并支持用户上传 Skills。-- Maintained by CoPaper.AI from Stanford REAP.
🔬 A curated collection of 23,000+ agent skills for empirical research across 8 social science disciplines. | 精选 23,000+ AI Agent 技能库，覆盖8大社会科学学科的实证研究。CoPaper.AI 20分钟完成一篇可复现的规范实证论文，并支持用户上传 Skills。-- Maintained by CoPaper.AI from Stanford REAP.
AgentNetworkProtocol(ANP) is an open source protocol for agent communication. Our vision is to define how agents connect with each other, building an open, secure, and efficient collaboration network for billions of intelligent agents.
Learn how to use the c-slack Claude skill. Complete guide with installation instructions and examples.
Learn how to use the c-telegram Claude skill. Complete guide with installation instructions and examples.
Learn how to use the Letter Writer Claude skill. Complete guide with installation instructions and examples.