Native iOS and macOS development plugin with deep expertise in SwiftUI, Swift 6 concurrency, SwiftData, XcodeBuildMCP integration, and Apple platform conventions.
Build the project via XcodeBuildMCP
Scaffold a complete feature module
Create a Product Requirements Document from discussion
Scaffold a SwiftUI view + ViewModel
Diagnose and fix build errors
macOS AppKit specialist. Use for NSWindow management, NSSplitViewController (3-pane layouts), NSOutlineView source lists, NSToolbar, menus and menu bar, and hosting SwiftUI views inside AppKit containers. Handles production macOS apps that need full native integration beyond what SwiftUI alone provides. Trigger on: "macOS," "AppKit," "NSWindow," "toolbar," "sidebar," "NSOutlineView," "NSSplitViewController," "menu," "menu bar," "NSToolbar," "source list," or any macOS-specific UI task. <example> Context: User wants a 3-pane macOS app layout user: "Build a 3-column macOS app with sidebar, content, and inspector" assistant: "I'll use the appkit-specialist agent to design the NSSplitViewController layout with SwiftUI content views." <commentary> Classic macOS 3-pane layout — appkit-specialist designs the window architecture. </commentary> </example> <example> Context: User needs a source list sidebar user: "Create a sidebar with expandable groups like Finder's sidebar" assistant: "I'll use the appkit-specialist agent to implement an NSOutlineView source list." <commentary> Source list implementation — appkit-specialist uses NSOutlineView for native behavior. </commentary> </example> <example> Context: User wants toolbar customization user: "Add a customizable toolbar with search, view mode, and share buttons" assistant: "I'll use the appkit-specialist agent to implement NSToolbar with proper item configuration." <commentary> Toolbar task — appkit-specialist builds NSToolbar with native macOS conventions. </commentary> </example>
Swift 6 concurrency specialist. Use for async/await patterns, actor isolation, Sendable conformance, @MainActor annotation, structured and unstructured concurrency, AsyncSequence, and fixing strict concurrency warnings. Every concurrency warning is a potential data race. This agent resolves them without suppression. Trigger on: "async," "await," "actor," "Sendable," "@MainActor," "concurrency warning," "data race," "Task," "TaskGroup," "AsyncSequence," "AsyncStream," or any Swift concurrency task. <example> Context: User has concurrency warnings after enabling strict checking user: "I'm getting 'Sending main actor-isolated value to nonisolated context' warnings everywhere" assistant: "I'll use the concurrency-specialist agent to diagnose and fix each warning systematically." <commentary> Concurrency warning resolution — the core use case for this agent. </commentary> </example> <example> Context: User needs to design an actor-based service user: "Design a thread-safe cache that can be used from any context" assistant: "I'll use the concurrency-specialist agent to design an actor-based cache with proper isolation." <commentary> Actor design task — concurrency-specialist designs the isolation boundary. </commentary> </example> <example> Context: User needs to process items in parallel user: "Download thumbnails for 50 items concurrently with a limit of 5 at a time" assistant: "I'll use the concurrency-specialist agent to implement a TaskGroup with concurrency throttling." <commentary> Structured concurrency with throttling — concurrency-specialist territory. </commentary> </example>
Swift networking specialist. Use for URLSession async/await, Codable encoding/decoding, token-based authentication (JWT refresh), retry logic, endpoint abstraction, typed errors, and async sequence streaming. Handles all network layer concerns from API client design to error handling. Trigger on: "URLSession," "networking," "API client," "Codable," "JSON," "JWT," "token refresh," "retry," "endpoint," "HTTP," "REST," "download," or any networking task. <example> Context: User wants to build an API client user: "Build a type-safe API client for our REST backend" assistant: "I'll use the networking-engineer agent to design the actor-based APIClient with typed endpoints." <commentary> API client design — networking-engineer builds the full networking layer. </commentary> </example> <example> Context: User needs JWT token refresh user: "Implement automatic token refresh when the API returns 401" assistant: "I'll use the networking-engineer agent to add JWT refresh logic to the API client." <commentary> Token auth task — networking-engineer handles the refresh dance. </commentary> </example> <example> Context: User needs to decode complex JSON user: "The API returns nested JSON with snake_case keys and optional fields" assistant: "I'll use the networking-engineer agent to write the Codable models with a custom decoder." <commentary> Codable task — networking-engineer designs the decoding strategy. </commentary> </example>
Apple platform integration specialist. Use for Spotlight indexing, WidgetKit extensions, Share Extensions, App Intents (Shortcuts), CloudKit, push notifications (APNs), App Groups, and StoreKit 2. Handles all system framework integration that extends the app beyond its main process. Trigger on: "Spotlight," "Widget," "Extension," "Shortcuts," "Intents," "CloudKit," "push notification," "APNs," "App Group," "StoreKit," "in-app purchase," or any platform integration task. <example> Context: User wants Spotlight search integration user: "Make claims searchable from the iOS Spotlight search" assistant: "I'll use the platform-integrator agent to implement CSSearchableItem indexing." <commentary> Spotlight integration — platform-integrator indexes domain objects for system-wide search. </commentary> </example> <example> Context: User wants a home screen widget user: "Create a widget showing recent claims on the home screen" assistant: "I'll use the platform-integrator agent to build the WidgetKit extension with a TimelineProvider." <commentary> Widget creation — platform-integrator builds the timeline provider and widget views. </commentary> </example> <example> Context: User wants Siri Shortcuts integration user: "Let users add a claim via Siri using App Intents" assistant: "I'll use the platform-integrator agent to implement the App Intent and parameter resolution." <commentary> App Intents task — platform-integrator defines the intent, parameters, and perform method. </commentary> </example>
Core Swift architecture agent and plugin hub. Use for app scaffolding, MVVM with @Observable, NavigationStack routing, module structure, dependency injection, and general architecture decisions. This is the default entry point for any Swift task. It routes to specialized agents when deeper expertise is needed (swiftui-builder for views, swiftdata-engineer for persistence, concurrency-specialist for async/actors, platform-integrator for system frameworks, networking-engineer for API clients, appkit-specialist for macOS, test-engineer for testing). Trigger on: any Swift app request, "build an app," "create a feature," "architecture," "MVVM," "navigation," "module structure," "dependency injection," or general Swift project questions. <example> Context: User wants to start a new iOS app user: "Build a knowledge graph app for iOS with SwiftData persistence" assistant: "I'll use the swift-architect agent to design the app architecture, module structure, and navigation hierarchy." <commentary> New app scaffold — swift-architect designs the foundation, then routes to swiftdata-engineer for models and swiftui-builder for views. </commentary> </example> <example> Context: User asks about structuring a feature module user: "How should I structure the search feature with its own ViewModel and views?" assistant: "I'll use the swift-architect agent to design the feature module with MVVM and @Observable." <commentary> Feature architecture question — swift-architect defines module boundaries, ViewModel shape, and view hierarchy. </commentary> </example> <example> Context: User needs navigation architecture user: "Set up type-safe navigation with deep linking support" assistant: "I'll use the swift-architect agent to design the NavigationStack routing layer." <commentary> Navigation design — swift-architect owns the routing enum and NavigationStack configuration. </commentary> </example>
Modifies files
Hook triggers on file write and edit operations
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Most Claude Code plugins give you a set of slash commands and some domain knowledge. These plugins do something different: they learn.
Each plugin in this repo is a domain-specialized engineering intelligence that accumulates knowledge across sessions, grounds itself in real library source code (not training data), and coordinates with a companion chat skill on Claude.ai. The plugin implements. The chat skill plans. Over time, the plugin gets better at its job because it tracks what works, what doesn't, and what it's still uncertain about.
This is the two-surface architecture: one surface for thinking, one for building.
A typical plugin contains four layers:
Specialist agents and slash commands. Each plugin ships with 3 to 7 agents that handle specific subtasks. UI-Design-Pro has a design critic, a component builder, an accessibility auditor, an animation engineer, and a visual architect. Django-Engine-Pro has agents for model design, ORM optimization, migration planning, and MCP server exposure. Agents compose in defined sequences: you always run the stack detector before the component builder, always run the design critic after.
Source-code references. Plugins include install.sh scripts that shallow-clone real library repos into a local refs/ directory. When UI-Design-Pro needs to know how Radix handles focus restoration, it greps the actual Radix source, not its training data. When D3-Pro needs to verify a scale constructor's API, it reads the Observable source directly. This matters because training data goes stale. Source code doesn't.
Skills and decision frameworks. Static knowledge: inheritance decision tables, ORM anti-pattern catalogs, polymorphic rendering rules, animation physics constants. These encode the expert judgment that doesn't change between sessions.
An epistemic knowledge layer. This is the part that learns. Each plugin maintains a knowledge/ directory containing typed claims in JSONL, confidence scores, session logs, and (for some plugins) SBERT embeddings. Claims start as drafts. After review, they become active. Active claims carry Bayesian confidence that updates based on session outcomes: when a suggestion informed by a claim gets accepted, confidence rises; when it gets rejected, confidence drops. Over time, each plugin develops its own body of verified, weighted knowledge about its domain.
Each plugin here has a counterpart: a chat skill that runs on Claude.ai (or Claude Desktop). The division of labor is deliberate.
The chat skill handles planning, reasoning, and decision-making. When you're deciding between DRF and Ninja for an API, or choosing an inheritance strategy for a model hierarchy, or evaluating whether a component needs polymorphic rendering, the chat skill walks you through the tradeoffs and produces a structured handoff document.
The Claude Code plugin handles implementation and learning. It takes the handoff document, builds the thing, greps real source code when it needs to verify an API, logs what it tried, and updates its knowledge base with what it learned.
The chat skill never sees knowledge/claims.jsonl. The plugin never produces planning documents. Each surface does what it's good at.
| Chat Skill (Claude.ai) | Claude Code Plugin |
|---|---|
| Decision frameworks | Slash commands and agents |
| Tradeoff analysis | Source-code grepping |
| Structured handoff docs | Implementation and testing |
| Domain reasoning | Session logging and learning |
| Static (expert knowledge) | Dynamic (knowledge that evolves) |
Every plugin with a knowledge/ directory runs the same protocol:
Session start: Read manifest.json for current state. Load active claims sorted by confidence. Check tensions.jsonl for unresolved conflicts in the task's domain. Surface tensions before making decisions, not after.
During work: Track which claims informed each suggestion. Note when the user accepts, modifies, or rejects a recommendation.
Session end: Write observations to session_log/. Flag contradictions as tension signals. Note recurring patterns the knowledge base doesn't yet cover.
The knowledge types are borrowed from Theseus (a separate epistemic engine project):
Current knowledge stats across the fleet:
| Plugin | Total Claims | Active | Avg Confidence |
|---|---|---|---|
| UI-Design-Pro | 140 | 135 | 0.667 |
| Django-Engine-Pro | 111 | 29 | 0.75 |
npx claudepluginhub travis-gilbert/claude-marketplace --plugin swift-proMobile app development specialist: PWA retrofitting, React Native architecture, offline-first sync, mobile API design, touch optimization, and mobile visualization adaptation.
Makes Claude Code extraordinarily good at transforming websites into applications: converting page-based Next.js sites into app-like experiences with persistent layouts, command palettes, and background sync; wrapping them in Tauri desktop shells with native OS integration; and producing architecture handoffs for native Swift/AppKit macOS apps.
Makes Claude Code genuinely good at designing knowledge-graph answer experiences with cosmos.gl on top of DuckDB-WASM, Mosaic, and vgplot. Owns the SceneDirective adapter, the three-picker ControlDock (Position, Weight, Edges), and the recipe library that turns novel ideas into usable images.
Git and deployment automation with verification at every step. Staged file review, conventional commits, pre-commit checks, push with CI/CD detection, and post-deploy health verification.
Makes Claude Code extraordinarily good at building D3 visualizations that are mathematically accurate, physically believable, and aesthetically grounded in the Mike Bostock / Observable canon.
Intelligent draw.io diagramming plugin with AI-powered diagram generation, multi-platform embedding (GitHub, Confluence, Azure DevOps, Notion, Teams, Harness), conditional formatting, live data binding, and MCP server integration for programmatic diagram creation and management.
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Feature development with code-architect/explorer/reviewer agents, CLAUDE.md audit and session learnings, and Agent Skills creation with eval benchmarking from Anthropic.
Production-grade engineering skills for AI coding agents — covering the full software development lifecycle from spec to ship.
Persistent file-based planning for AI coding agents. Crash-proof markdown plans (task_plan.md, findings.md, progress.md) that survive context loss and /clear, with an opt-in completion gate and multi-agent shared state. Manus-style. Works with Claude Code, Codex CLI, Cursor, Kiro, OpenCode and 60+ agents via the SKILL.md standard. Includes Arabic, German, Spanish, and Chinese (Simplified and Traditional).
Access thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.