The AI Coding Plugins Ecosystem: 185+ Productivity Tools from OpenAI, Anthropic, and Beyond on Explainx.ai

The AI coding assistant landscape has evolved from isolated tools to a comprehensive plugin ecosystem connecting developers with their entire productivity stack. As of June 2026, Explainx.ai has cataloged 185+ plugins from OpenAI, Anthropic, and third-party developers—spanning design tools (Figma, Canva), project management (Notion, Linear, Asana), development infrastructure (GitHub, Vercel, Netlify), communication (Slack, Gmail, Zoom), analytics (PostHog, Mixpanel), and specialized workflows (Stripe payments, DocuSign contracts, Shopify e-commerce).

This represents a fundamental shift in how developers work with AI. Rather than copying code between tools, switching contexts across dozens of SaaS platforms, or manually translating requirements into implementations, plugins enable AI assistants to directly integrate with your workflows—reading Figma designs, creating Linear tickets, deploying to Vercel, sending Slack notifications, and analyzing PostHog metrics—all within a single conversational interface.

The plugin architecture borrows from successful ecosystems like VS Code extensions, Figma plugins, and Shopify apps: lightweight manifests, declarative tool definitions, and standardized authentication. OpenAI's Codex and Anthropic's Claude Code both support the .codex-plugin manifest format, enabling cross-platform compatibility and a unified developer experience.

This comprehensive guide explores what plugins are, how they work architecturally, the 185+ available plugins across 12 categories, how to discover and install plugins, building custom plugins, and the future of the AI productivity ecosystem.

Part I: What Are AI Coding Plugins?

Definition

AI coding plugins are modular extensions that connect AI coding assistants (Claude Code, Codex CLI, Cursor) to external services, tools, and APIs—enabling the AI to:

1. Read data from productivity tools (Notion pages, Linear issues, Figma designs)
2. Execute actions (create GitHub PRs, deploy to Vercel, send Slack messages)
3. Follow domain-specific workflows (Stripe payment setup, Shopify product creation)
4. Enforce patterns (design system compliance, code review standards)

Example without plugin:

User: "Add the user profile feature from our Figma design to the app."

Claude Code (without Figma plugin):
"I don't have access to your Figma files. Can you describe the design or share a screenshot?"

[User exports Figma, takes screenshots, pastes into chat]
[Claude interprets screenshots, may misunderstand design details]

Example with plugin:

User: "Add the user profile feature from our Figma design to the app."

Claude Code (with Figma plugin):
1. Reads Figma file via API
2. Extracts design tokens (colors, spacing, typography)
3. Identifies components and layout structure
4. Generates code matching exact specifications
5. Applies design system constraints

Result: Pixel-perfect implementation in <2 minutes

How Plugins Differ from Skills

Skills (covered in our skills guide) are task-specific capabilities the AI can perform:

• Example skills: "debug-with-tests", "optimize-database-queries", "generate-api-docs"
• Scope: Behavioral patterns, reasoning workflows
• Implementation: Prompt engineering, agent orchestration

Plugins are integrations with external services:

• Example plugins: "figma", "notion", "stripe", "github"
• Scope: API connections, tool invocations
• Implementation: OAuth, REST APIs, MCP servers

Relationship:

Plugins enable skills. The "implement-figma-design" skill requires the Figma plugin to access design data.

Part II: Plugin Architecture

The .codex-plugin Manifest

Every plugin includes a .codex-plugin/plugin.json manifest defining:

{
  "name": "figma",
  "version": "1.2.0",
  "description": "Integrate Figma designs into coding workflows",
  "author": "OpenAI",
  "publisher": "openai",

  // Authentication
  "auth": {
    "type": "oauth2",
    "provider": "figma",
    "scopes": ["files:read", "comments:write"]
  },

  // Tools exposed to AI
  "tools": [
    {
      "name": "read_figma_file",
      "description": "Read a Figma file and extract design data",
      "parameters": {
        "file_key": "string",
        "node_ids": "array<string>?"
      }
    },
    {
      "name": "export_to_code",
      "description": "Generate code from Figma components",
      "parameters": {
        "component_id": "string",
        "framework": "react | vue | svelte"
      }
    }
  ],

  // Optional: Skills provided
  "skills": ["use_figma", "code_to_canvas", "design_system_validation"],

  // Optional: MCP server for advanced functionality
  "mcp_server": "figma-mcp",

  // Optional: Hooks for workflow integration
  "hooks": {
    "before_edit": ["validate_design_tokens"],
    "after_commit": ["sync_to_figma"]
  }
}

How Plugins Are Invoked

User request:

User: "Update the button styles to match our Figma design system."

AI decision process:

1. Intent recognition: User wants to sync code with Figma designs
2. Plugin discovery: Check available plugins for Figma integration
3. Tool selection: Choose figma.read_figma_file tool
4. Authentication: Verify user has authorized Figma OAuth
5. API call: Fetch design system tokens from Figma
6. Code generation: Update button components to match
7. Optional: Invoke validate_design_tokens hook to ensure compliance

Under the hood:

# AI assistant (simplified)
def handle_request(user_message):
    intent = classify_intent(user_message)  # "sync_figma_design"

    if intent == "sync_figma_design":
        figma_plugin = load_plugin("figma")

        # Call plugin tool
        design_data = figma_plugin.tools["read_figma_file"](
            file_key="abc123",
            node_ids=["button-primary"]
        )

        # Generate code based on design data
        updated_code = generate_button_component(design_data)

        # Apply code
        edit_file("src/components/Button.tsx", updated_code)

        return "Button styles updated to match Figma design system."

Plugin Types

1. API Integration Plugins

Connect to external SaaS platforms via REST APIs.

Examples: Figma, Notion, Linear, Stripe, GitHub

Characteristics:

• OAuth authentication
• Rate limits apply
• Real-time data sync

2. Development Tool Plugins

Enhance coding workflows with specialized tools.

Examples: Build iOS Apps, Build Web Apps, Expo, Netlify

Characteristics:

• Local tool invocations (Xcode, npm, CLI tools)
• File system access
• Build/deploy orchestration

3. Communication Plugins

Enable AI to interact with team communication tools.

Examples: Slack, Gmail, Zoom, Teams

Characteristics:

• Send messages, schedule meetings
• Read notifications
• Workflow automation

4. Data & Analytics Plugins

Query analytics platforms for insights.

Examples: PostHog, Mixpanel, Amplitude, Datadog

Characteristics:

• Query metrics
• Generate reports
• Anomaly detection

5. MCP (Model Context Protocol) Plugins

Advanced plugins using the MCP standard for complex integrations.

Examples: Atlassian Rovo, HubSpot, Salesforce

Characteristics:

• Bidirectional data sync
• Complex multi-step workflows
• Enterprise authentication (SSO, SAML)

Part III: The 185+ Plugin Ecosystem

Breakdown by Category

As of June 7, 2026, Explainx.ai catalogs 185 plugins:

Total: 185 plugins

Featured Plugin Deep Dives

1. Figma Plugin (openai-figma)

What it does:

• Read Figma files and extract design data
• Convert designs to code (React, Vue, Svelte)
• Sync code changes back to Figma (Code to Canvas)
• Enforce design system compliance

Tools:

• read_figma_file - Fetch design data
• export_component - Generate code from components
• validate_design_tokens - Check color/spacing compliance
• create_figma_comment - Add comments to designs

Use cases:

• Implement designs pixel-perfectly
• Keep code and design in sync
• Automated design QA
• Designer-developer collaboration

Authentication: OAuth with Figma account

2. Notion Plugin (openai-notion)

What it does:

• Read and write Notion pages
• Create databases, tasks, and project roadmaps
• Search knowledge bases
• Sync documentation from code

Tools:

• search_notion - Query pages/databases
• create_page - Create new pages
• update_page - Edit existing content
• query_database - Filter and sort databases

Use cases:

• Generate project plans
• Sync API docs to Notion
• Create meeting notes from code changes
• Track progress automatically

Authentication: OAuth with Notion workspace

3. Linear Plugin (openai-linear)

What it does:

• Create and update Linear issues
• Assign tasks to team members
• Link code changes to issues
• Track project progress

Tools:

• create_issue - Create new issues
• update_issue - Modify existing issues
• search_issues - Query issues
• create_project - Set up new projects

Use cases:

• Automatically create issues from bugs found in code review
• Link commits to Linear issues
• Generate sprint reports
• Track feature implementation progress

Authentication: API key or OAuth

4. Stripe Plugin (openai-stripe)

What it does:

• Implement payment flows
• Manage subscriptions
• Handle webhooks
• Query transaction data

Tools:

• create_checkout_session - Generate payment links
• create_subscription - Set up recurring billing
• handle_webhook - Process Stripe events
• query_customers - Fetch customer data

Use cases:

• Add checkout to web apps
• Implement subscription management
• Set up usage-based billing
• Generate financial reports

Authentication: API keys (test/production)

5. GitHub Plugin (openai-github)

What it does:

• Create pull requests
• Review code
• Manage issues
• Run CI/CD workflows

Tools:

• create_pr - Open pull requests
• review_code - Submit code reviews
• create_issue - File bugs/features
• run_workflow - Trigger GitHub Actions

Use cases:

• Automated pull request creation
• AI-powered code review
• Issue triage
• Release automation

Authentication: GitHub token or OAuth

6. Slack Plugin (openai-slack)

What it does:

• Send messages to channels/DMs
• Read conversations
• Create reminders
• Integrate with workflows

Tools:

• send_message - Post to channels
• read_channel - Fetch messages
• create_reminder - Set reminders
• upload_file - Share files

Use cases:

• Notify team of deployments
• Share build status
• Answer questions from Slack
• Automate standup updates

Authentication: Slack OAuth

7. Vercel Plugin (openai-vercel)

What it does:

• Deploy web applications
• Manage environment variables
• Query deployment logs
• Configure domains

Tools:

• deploy - Deploy to Vercel
• get_deployments - List deployments
• get_logs - Fetch deployment logs
• manage_env - Set environment variables

Use cases:

• One-command deployments
• Automatic preview deploys
• Environment management
• Domain configuration

Authentication: Vercel token

8. PostHog Plugin (openai-posthog)

What it does:

• Query product analytics
• Track events
• Analyze user behavior
• Create dashboards

Tools:

• query_events - Fetch event data
• create_insight - Generate analytics
• track_event - Log events
• create_dashboard - Build dashboards

Use cases:

• Analyze feature usage
• Track conversion funnels
• Debug user issues
• Generate growth reports

Authentication: PostHog API key

Anthropic-Specific Plugins

Anthropic contributes 13 specialized plugins for Claude Code:

Developer Experience:

• anthropic-code-review - Automated code review with best practices
• anthropic-commit-commands - Smart commit message generation
• anthropic-feature-dev - Feature development workflows
• anthropic-pr-review-toolkit - Pull request review automation

Developer Productivity:

• anthropic-hookify - Custom hook creation for workflows
• anthropic-plugin-dev - Build new plugins
• anthropic-agent-sdk-dev - Develop custom agents
• anthropic-security-guidance - Security best practices enforcement

Output Customization:

• anthropic-frontend-design - UI/UX best practices
• anthropic-learning-output-style - Educational explanations
• anthropic-explanatory-output-style - Detailed reasoning
• anthropic-ralph-wiggum - Humorous/simplified responses

Migration Tools:

• anthropic-claude-opus-4-5-migration - Upgrade code to Opus 4.5 API

Key differentiators:

Anthropic plugins focus on developer experience improvements and workflow customization rather than external service integrations—reflecting Anthropic's emphasis on Claude Code being a developer-first tool.

Part IV: Discovering and Installing Plugins

Explainx.ai Plugin Directory

Explainx.ai/plugins serves as the centralized registry for all 185+ plugins:

Features:

✅ Search & Filter

• Search by name, category, or functionality
• Filter by provider (OpenAI, Anthropic, third-party)
• Sort by popularity, recently added, or rating

✅ Plugin Details

• Description and use cases
• Tools and capabilities
• Authentication requirements
• Installation instructions
• Compatibility (Claude Code, Codex CLI, Cursor)

✅ Community Ratings

• User reviews
• Usage statistics
• Issue tracking

Installing Plugins

For Claude Code:

# Install single plugin
claude plugins install openai-figma

# Install multiple plugins
claude plugins install openai-notion openai-linear openai-stripe

# List installed plugins
claude plugins list

# Update plugins
claude plugins update

For Codex CLI:

# Install plugin
codex plugins add openai-github

# Enable plugin
codex plugins enable openai-github

# List plugins
codex plugins ls

Manual Installation:

# Clone plugin repository
git clone https://github.com/openai/plugins.git

# Navigate to plugin directory
cd plugins/figma

# Install
claude plugins install .

Plugin Authentication

Many plugins require OAuth or API key authentication:

OAuth workflow:

# Install plugin
claude plugins install openai-figma

# Authenticate
claude plugins auth openai-figma

# Opens browser for OAuth consent
[Figma login page opens]
[User grants permissions]
[Redirected back to CLI]

✅ Authentication successful

API key workflow:

# Install plugin
claude plugins install openai-stripe

# Set API key
claude plugins config openai-stripe --api-key sk_test_abc123

# Or use environment variable
export STRIPE_API_KEY=sk_test_abc123

Part V: Building Custom Plugins

When to Build a Custom Plugin

Build a plugin if:

✅ You need integration with a proprietary internal tool ✅ No existing plugin supports your workflow ✅ You want to enforce company-specific patterns ✅ You're building a product and want AI integration

Use existing plugins if:

❌ An official or community plugin already exists ❌ The integration is simple (better as a skill) ❌ You don't need persistent authentication

Plugin Development Workflow

Step 1: Create Plugin Structure

mkdir my-company-plugin
cd my-company-plugin

# Create manifest
mkdir .codex-plugin
touch .codex-plugin/plugin.json

Step 2: Define Manifest

{
  "name": "my-company-crm",
  "version": "1.0.0",
  "description": "Integration with our internal CRM",
  "author": "Your Company",

  "auth": {
    "type": "api_key",
    "env_var": "CRM_API_KEY"
  },

  "tools": [
    {
      "name": "get_customer",
      "description": "Fetch customer data by ID",
      "parameters": {
        "customer_id": {
          "type": "string",
          "description": "Customer ID"
        }
      }
    },
    {
      "name": "create_deal",
      "description": "Create a new deal in CRM",
      "parameters": {
        "customer_id": "string",
        "amount": "number",
        "close_date": "string"
      }
    }
  ]
}

Step 3: Implement Tool Functions

Option A: MCP Server (Recommended)

// server.ts
import { MCPServer } from '@anthropic/mcp-sdk';

const server = new MCPServer({
  name: 'my-company-crm',
  version: '1.0.0'
});

server.tool('get_customer', async ({ customer_id }) => {
  const response = await fetch(`https://crm.mycompany.com/api/customers/${customer_id}`, {
    headers: { 'Authorization': `Bearer ${process.env.CRM_API_KEY}` }
  });

  return await response.json();
});

server.tool('create_deal', async ({ customer_id, amount, close_date }) => {
  const response = await fetch(`https://crm.mycompany.com/api/deals`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.CRM_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ customer_id, amount, close_date })
  });

  return await response.json();
});

server.start();

Option B: Simple Script Integration

# tools/get_customer.py
import os
import requests

def get_customer(customer_id: str):
    api_key = os.getenv('CRM_API_KEY')
    response = requests.get(
        f'https://crm.mycompany.com/api/customers/{customer_id}',
        headers={'Authorization': f'Bearer {api_key}'}
    )
    return response.json()

Step 4: Add Skills (Optional)

<!-- skills/create_sales_pipeline.md -->
# create_sales_pipeline

Create a complete sales pipeline for a new customer.

## Usage

When the user asks to set up a new customer in the CRM:

1. Use `get_customer` to check if customer exists
2. If not, create customer record
3. Use `create_deal` to set up initial deal
4. Send Slack notification to sales team

## Example

User: "Add Acme Corp as a new customer with a $50k deal closing next month."

Step 5: Test Plugin

# Install locally
claude plugins install .

# Test tool invocation
claude "Get customer data for ID cust_123"

# Expected: Plugin fetches customer from CRM

Step 6: Publish (Optional)

For company-internal use:

# Host on internal package registry
npm publish --registry https://npm.mycompany.com

For public distribution:

# Publish to Explainx registry
explainx plugins publish .

# Or submit to OpenAI/Anthropic repositories
gh repo fork openai/plugins
# Add your plugin to plugins/ directory
# Submit pull request

Plugin Development Best Practices

1. Single Responsibility

Each plugin should focus on one service/tool:

✅ Good: stripe plugin handles payments ❌ Bad: finance plugin handles Stripe, QuickBooks, and Plaid

2. Clear Tool Naming

Use descriptive, action-oriented tool names:

✅ Good: create_checkout_session, cancel_subscription ❌ Bad: stripe_do_thing, helper_function

3. Robust Error Handling

server.tool('get_customer', async ({ customer_id }) => {
  try {
    const response = await fetch(`https://api.company.com/customers/${customer_id}`);

    if (!response.ok) {
      if (response.status === 404) {
        return { error: `Customer ${customer_id} not found` };
      }
      if (response.status === 401) {
        return { error: 'Authentication failed. Check your API key.' };
      }
      throw new Error(`API error: ${response.status}`);
    }

    return await response.json();
  } catch (error) {
    return { error: `Failed to fetch customer: ${error.message}` };
  }
});

4. Rate Limit Awareness

import { RateLimiter } from 'limiter';

const limiter = new RateLimiter({
  tokensPerInterval: 100,
  interval: 'minute'
});

server.tool('api_call', async (params) => {
  await limiter.removeTokens(1);
  // Make API call
});

5. Secure Authentication

// ❌ Bad: Hardcoded API key
const API_KEY = 'sk_live_abc123';

// ✅ Good: Environment variable
const API_KEY = process.env.CRM_API_KEY;

// ✅ Better: OAuth with token refresh
import { OAuth2Client } from 'google-auth-library';
const oauth = new OAuth2Client(CLIENT_ID, CLIENT_SECRET);

Part VI: Real-World Plugin Workflows

Workflow 1: Design-to-Code Pipeline

Plugins used: Figma + GitHub + Vercel + Slack

Scenario: Designer updates Figma, AI implements changes and deploys.

User: "Update the landing page to match the latest Figma design and deploy."

AI Workflow:
1. [Figma plugin] Read Figma file, identify changes
2. [File operations] Update React components
3. [GitHub plugin] Create pull request with changes
4. [Vercel plugin] Deploy preview environment
5. [Slack plugin] Notify #design channel with preview link

Result: Design changes live on preview URL in <5 minutes

Workflow 2: Customer Support Automation

Plugins used: Gmail + Linear + Notion + Slack

Scenario: Convert support emails to Linear issues with context.

User: "Triage my support emails and create Linear issues for bugs."

AI Workflow:
1. [Gmail plugin] Read recent support emails
2. Classify emails (bug, feature request, question)
3. [Linear plugin] Create issues for bugs with email context
4. [Notion plugin] Log feature requests in product roadmap
5. [Gmail plugin] Send acknowledgment to customers
6. [Slack plugin] Notify #support channel with summary

Result: 20 emails triaged, 5 issues created, customers notified in <2 minutes

Workflow 3: Analytics-Driven Development

Plugins used: PostHog + Linear + GitHub

Scenario: Identify underperforming features and create optimization tasks.

User: "Analyze our signup funnel and create tasks to fix drop-off points."

AI Workflow:
1. [PostHog plugin] Query signup funnel conversion rates
2. Identify steps with >20% drop-off
3. [GitHub plugin] Read relevant code files
4. Diagnose potential issues (slow API, confusing UI, etc.)
5. [Linear plugin] Create optimization tasks with context
6. [GitHub plugin] Open draft PRs with proposed fixes

Result: 3 bottlenecks identified, 3 Linear issues created with PRs in <10 minutes

Workflow 4: E-commerce Product Launch

Plugins used: Shopify + Stripe + Canva + SendGrid

Scenario: Launch a new product with complete setup.

User: "Launch our new 'Pro Plan' subscription product."

AI Workflow:
1. [Stripe plugin] Create subscription product and pricing tiers
2. [Stripe plugin] Set up webhook for subscription events
3. [Shopify plugin] Create product listing
4. [Canva plugin] Generate product images from templates
5. [SendGrid plugin] Create email campaign for announcement
6. [Code] Implement checkout flow in app
7. [Vercel plugin] Deploy updated app

Result: Complete product launch (backend + frontend + marketing) in <30 minutes

Part VII: Plugin Ecosystem Economics

Who Builds Plugins?

1. First-Party (OpenAI/Anthropic)

• Core development tools (Build iOS Apps, Build Web Apps)
• Popular services with official partnerships (Figma, Stripe)
• ~30-40 plugins

2. Service Providers

• Companies building plugins for their own products
• Examples: PostHog, Vercel, Linear, Notion
• ~60-70 plugins

3. Community Developers

• Open-source enthusiasts
• Agencies building for clients
• Individual developers scratching their own itch
• ~80-85 plugins

Monetization Models

Free (Open Source)

• Most plugins are free
• Funded by service provider marketing budgets
• Or community-maintained

Freemium

• Basic plugin free
• Advanced features require paid plan
• Example: Analytics plugin with free tier (1K events/month), paid tier (unlimited)

Enterprise

• Custom plugins for enterprise contracts
• Built by agencies or internal teams
• Not publicly listed

Marketplace Revenue Share (Future)

Explainx.ai may introduce:

• Paid plugin marketplace
• 70/30 revenue split (developer/platform)
• Premium plugins for specialized workflows

Part VIII: The Future of AI Plugins

Trends for 2026-2027

1. Auto-Discovery

AI assistants will automatically suggest plugins based on user intent:

User: "Deploy this app to production."

AI: "I noticed you don't have the Vercel plugin installed.
     Would you like me to install it and deploy?"

[User: Yes]

AI: [Installs Vercel plugin, authenticates, deploys]

2. Plugin Composition

Chains of plugins working together without explicit orchestration:

User: "When I push to main, run tests, deploy to Vercel, and notify Slack."

AI: [Creates workflow linking GitHub + Vercel + Slack plugins]

3. AI-Generated Plugins

AI assistants generating custom plugins on-demand:

User: "I need a plugin for our internal API at api.company.com/docs."

AI:
1. Reads API documentation
2. Generates plugin manifest
3. Implements tool functions
4. Tests plugin
5. Installs for user

Result: Custom plugin ready in <5 minutes

4. Cross-Assistant Compatibility

Plugins work across Claude Code, Codex CLI, Cursor, and future tools via standardized manifest format.

5. Enterprise Plugin Marketplaces

Companies building internal plugin repositories:

• Salesforce plugin for CRM data
• SAP plugin for ERP workflows
• Custom internal tools

Predictions: Plugin Ecosystem in 2028

185 plugins (June 2026) → 1,000+ plugins (2028)

Categories will expand to:

• Healthcare (HIPAA-compliant medical records integration)
• Legal (Contract analysis, case law research)
• Education (LMS integrations, grading automation)
• Manufacturing (CAD tools, supply chain management)
• Finance (Bloomberg Terminal, trading platforms)

Plugin quality will improve:

• Standardized testing frameworks
• Security audits for sensitive integrations
• Performance monitoring
• Automatic deprecation warnings

AI assistants will become plugin orchestration platforms:

Rather than just calling individual tools, AI will:

• Chain multiple plugins for complex workflows
• Learn user preferences for plugin selection
• Automatically update and maintain plugins
• Suggest new plugins based on usage patterns

Conclusion: The Productivity Operating System

The AI coding plugin ecosystem represents a fundamental shift from isolated tools to an integrated productivity operating system. Rather than context-switching between Figma, Notion, Linear, Slack, Vercel, PostHog, and dozens of other tools, developers can now orchestrate their entire workflow through conversational interfaces powered by 185+ specialized plugins.

What makes this ecosystem successful:

1. ✅ Low barrier to entry - Simple manifest format, clear tool definitions
2. ✅ Cross-platform compatibility - Works across Claude Code, Codex CLI, Cursor
3. ✅ Service provider buy-in - Companies building official plugins
4. ✅ Community momentum - Open-source contributions accelerating
5. ✅ Explainx.ai registry - Centralized discovery and documentation

For developers in 2026:

• Discover plugins: Explainx.ai/plugins
• Install essentials: Figma, Notion, Linear, Stripe, GitHub, Vercel, PostHog
• Experiment with workflows: Combine plugins for multi-step automation
• Build custom plugins: Integrate internal tools for your team

Looking ahead:

As the plugin count grows from 185 to 1,000+, the challenge shifts from "Can I integrate this tool?" to "Which of the 50 available integrations should I use?" Plugin quality, documentation, and community support will become the key differentiators.

The future of productivity is not more tools—it's better orchestration of existing tools. AI plugins are the infrastructure layer making that vision reality.

Resources

Plugin Discovery:

• Explainx.ai Plugin Directory - 185+ plugins cataloged
• OpenAI Plugins Repository - Official OpenAI plugins
• Anthropic Claude Code Docs - Claude-specific plugins

Plugin Development:

• MCP SDK Documentation - Build MCP-based plugins
• Plugin Development Guide - OpenAI plugin architecture
• Example Plugins - Reference implementations

Featured Plugin Documentation:

• Figma Plugin
• Notion Plugin
• Linear Plugin
• Stripe Plugin
• PostHog Plugin

Community:

• Plugin Developer Discord
• Explainx.ai Community Forum
• r/AIPlugins Subreddit