DevOps plugins for Claude Code

ECC is a comprehensive agent harness platform for Claude Code with 68 agents, 292 skills, and 94 legacy command shims, featuring reusable hooks, rules, and MCP conventions for engineering teams. It provides PostToolUse, PreToolUse, PreCompact, SessionStart/End, and Stop lifecycle hooks along with operator workflows integrated directly into Claude Code.

A comprehensive toolkit for developing Claude Code plugins with seven specialized skills covering hooks, MCP integration, plugin structure, settings, commands, agents, and skills. Includes guided workflow commands, example scripts, validation utilities, and best-practice documentation for building production-ready plugins.

Ralph Wiggum implements continuous self-referential AI loops that repeat the same prompt through a Stop hook until task completion, allowing iterative refinement within a single Claude Code session. The technique runs Claude in a while-true pattern with persistent file state, letting the model read its own past work and fix failures autonomously.

gstack is a comprehensive AI agent skill suite that transforms Claude Code into a virtual engineering team with 56 specialized skills spanning product review, design, security audits, testing, documentation, and deployment. Each skill is available as a slash command and automates workflows like CEO review, design consultation, code security audits, QA testing with real browsers, and release engineering.

Caveman compresses AI agent communication by shortening prose while preserving code, commands, and exact error messages, reducing input tokens by 33.2% and costs by up to 54% across multiple agents and platforms. It provides six optimization modes (Say Less, Read Less, Auto, Blocks, Waste Fixes, Browse) that work by hooking into SessionStart, SessionEnd, and UserPromptSubmit events to strip verbosity from both agent responses and data before model processing.

Claude-mem is a memory compression system for Claude Code that persists context across sessions through automated archival and retrieval of conversation state. It integrates via lifecycle hooks and shell commands to maintain searchable memory without external API dependencies.

RTK is a Rust binary for AI agents that intercepts and compresses shell command outputs (up to 90% smaller) before they reach the LLM context, supporting 100+ commands with <10ms overhead. The Agent Skill repo provides 12 skills for code review, design patterns, performance optimization, TDD workflows, security, and release automation focused on RTK filter development.

OmniRoute is a comprehensive AI gateway offering 46 standalone agent skills for managing a unified proxy to 372 AI providers with intelligent routing, cost tracking, compression, and multi-tool integration via CLI and JSON-RPC 2.0. The skills enable operators to control provider connections, batch inference, backups, evaluation suites, context engineering, and CLI tool auto-detection without requiring any external API keys or third-party services.

The ruflo-cost-tracker plugin provides token usage tracking, USD cost attribution per agent/model, and budget alerts with tiered warnings (50/75/90/100%) that can trigger hard stops. It includes 24 skills for cost analysis, optimization recommendations, anomaly detection, burn-rate trending, PR regression detection, and multi-provider ledger reporting.

This plugin provides lightweight startup hooks that initialize and manage Headroom deployments during Claude Code and GitHub Copilot CLI sessions. It runs shell commands at session start and before tool use to ensure a Headroom environment is ready, with flexible discovery of the Headroom binary across multiple installation locations.

Chrome DevTools for agents exposes Chrome browser automation, debugging, and performance analysis capabilities via an MCP server, using Puppeteer for reliable automation and Chrome DevTools for tracing and network inspection. The plugin lets AI coding assistants take screenshots, analyze performance traces, inspect network requests, and check console messages from a live Chrome instance.

This plugin enforces Cedar-based authorization policies on every Claude Code tool call and generates Ed25519-signed audit receipts that are independently verifiable offline. It prevents unauthorized tool execution before it happens and maintains a hash-chained trail of all decisions with cryptographic proof.

This plugin gates PR reviews, issue comments, merges, CI workflow edits, and other sensitive review-surface actions behind mandatory human approval, using Cedar policies and Ed25519-signed receipts for audit compliance. It prevents AI agents from taking unvetted actions that affect code review integrity and other contributors by requiring an explicit approval flag or slash command before high-impact tool calls execute.

This Claude Code plugin guides legacy codebase modernization through interactive steps that extract business rules, build interactive dependency maps, create approval-required upgrade plans, and then verify that modernized code behaves identically to the original using independent proof mechanisms. It supports any language and any modernization path (version upgrade, language rewrite, or architecture rebuild), includes security hardening, and generates one-page HTML reports tracking progress across assessment, mapping, rules extraction, planning, building, and verification phases.

Localhost iMessage-style web chat interface for testing Claude Code without external services, supporting message replies, edits, and file uploads/downloads. The plugin provides a single-browser testing surface with no persistent history or authentication, designed for development and debugging of the channel contract.

This plugin provides an MCP server that integrates Google Firebase, enabling management of Firestore databases, authentication, cloud functions, hosting, and storage directly from Claude. It requires the Firebase CLI (npx) to interact with your Firebase backend during development.

This GitLab plugin provides Claude Code with full integration to GitLab's DevOps platform, enabling management of repositories, merge requests, CI/CD pipelines, issues, and wikis directly from the IDE. It connects via a single MCP server to gitlab.com without requiring additional external tools or API keys.

laravel-boost is an MCP server that provides intelligent assistance for Laravel development, including Artisan commands, Eloquent queries, routing, migrations, and framework-specific code generation. It requires PHP to be installed locally and offers direct integration with Claude for Laravel-specific workflows.

This MCP server enables Claude to automate browser interactions using Playwright, supporting actions like taking screenshots, filling forms, and clicking elements on web pages. It provides end-to-end testing capabilities for automated browser workflows without requiring any external API keys.

Ralph Loop implements self-referential AI iteration loops in Claude Code, using a Stop hook to repeatedly feed the same prompt back until a completion signal is detected. This enables autonomous iterative development where Claude can build, test, debug, and refine work across multiple passes within a single session.

This Claude Code plugin wraps a Terraform MCP Server to enable Infrastructure as Code automation and interaction directly within Claude. It requires a TFE_TOKEN for Terraform Enterprise access and Docker for containerized execution.

9Router is a FREE AI gateway that routes requests to 40+ providers and 100+ models with OpenAI-compatible REST endpoints, RTK token compression to save 20-40% tokens, and auto-fallback between subscription and free tiers. The skill set provides nine capabilities for chat, embeddings, image/video/audio generation, speech transcription, and web search/fetch operations all routed through 9Router.

This Claude Code plugin transforms Claude into a data analyst, enabling SQL query writing, dataset exploration, statistical analysis, and interactive dashboard creation across any SQL-compatible data warehouse. It integrates with popular data stacks via MCP servers (Snowflake, BigQuery, Amplitude, Atlassian, etc.) and includes commands for ad-hoc analysis, data profiling, visualization, and pre-delivery validation.

The Zoom plugin guides developers through planning, building, and debugging Zoom integrations across REST APIs, SDKs, webhooks, bots, and MCP workflows with 57 skills covering OAuth setup, meeting apps, Team Chat, Phone, and Contact Center. It bundles three Zoom MCP servers for direct access to Zoom docs, user data, and whiteboard resources via bearer token authentication.

This plugin turns Anthropic's reference skill into a full domain framework for building and managing Claude Managed Agents, with deterministic scaffolders that compile user goals into single-pass workflows or bounded iteration loops. It orchestrates agent interviews, staging, grading, and scheduled deployments entirely through stdlib tools and BYOK curl scripts, never touching API keys directly.

This Playwright testing toolkit generates production-grade tests from specifications, fixes flaky failures, and migrates test suites from Cypress or Selenium—all via 3 specialized agents, 10 skills, and 55+ ready-to-use templates. Optional TestRail and BrowserStack integrations (manually enabled) enable test-case syncing and cross-browser reporting.

Context Mode is an MCP server that reduces context consumption by 98% through sandboxed code execution across 11 languages and maintains session continuity using FTS5-indexed SQLite tracking with automatic BM25 ranking on compaction. It enables agents to analyze data by writing scripts rather than reading raw files into context, and preserves task state and decisions across conversation resets without dumping data back into the window.

This skill helps diagnose and resolve macOS privacy permission (TCC) issues specific to OpenLogi, a Logitech device management application. Use it when triaging device visibility problems, permission prompts, or errors related to Input Monitoring, Accessibility, and code-signing on macOS.

This is a standalone Playwright CLI skill for coding agents that automates browser interactions, page testing, and web scraping through token-efficient command-line invocations rather than schema-heavy tool definitions. It includes two skills: one for general Playwright CLI browser automation and another for development workflows like dependency rolling and repository maintenance in the playwright-cli repository.

This standalone Agent Skill automates browser interactions and testing using Playwright, enabling test web pages and work with Playwright test files through CLI integration. It integrates directly with the Agent Skills runtime without requiring external API keys or dependencies.

The huggingface-skills plugin provides 25 Agent Skills that enable AI agents to interact with the Hugging Face Hub through the hf CLI and specialized workflow skills for tasks like model management, dataset operations, SageMaker deployment, and model evaluation. Skills are installable on-demand and compatible with Claude Code, Codex, Gemini CLI, and Cursor, with the hf-cli skill serving as the bootstrap for core Hub operations.

Desktop Commander provides Claude Code with an MCP server for terminal sessions, file operations, document handling, process management, and SSH workflows, along with six skills that guide the agent toward using these capabilities for common tasks. The plugin enables read-only system health checks, AI-tooling configuration, knowledge-base management, and Obsidian vault organization through a persistent shell and structured-data processing interface.

Worktrunk is a Claude Code plugin that integrates Git worktree management with activity tracking, showing which branches have active Claude sessions via 🤖/💬 indicators in `wt list` output. It provides configuration guidance for LLM commit messages, project hooks, and worktree paths, plus a `/wt-switch-create` command to spawn isolated branches for parallel AI workflows.

firstmate is an agent distribution system that lets you dispatch and supervise a crew of autonomous coding agents from a single conversation, each running in isolated git worktrees with task-specific instructions and reporting outcomes back to you. It integrates with supported agent harnesses (Claude Code, Grok, Pi, Cursor, etc.) and provides visible session backends (tmux, Herdr, Zellij, Orca) to coordinate parallel work on fixes, investigations, audits, and PRs across your projects.

This Claude Code plugin equips AI agents with 12 skills, a fal MCP server, and a CLI to reverse-engineer, modify, and test mods for almost any PC game—generating art, 3D models, and audio with fal, then documenting the process in a shared knowledge base. The agent automates the full modding loop: engine reconnaissance, code analysis, mod building, asset generation, in-game testing, video capture, and knowledge sharing.

dev-browser is a browser automation skill that lets coding agents control Chrome with JavaScript scripts, maintaining persistent named tabs across multiple calls for stateful workflows. The skill provides an accessibility-tree-based interface, real Puppeteer API support, and options to launch a new isolated Chrome profile or attach to an existing browser.

Expert Claude Code skills that teach AI how to build production-ready n8n workflows using the n8n-mcp MCP server, covering expression syntax, node configuration, validation, and deployment patterns. The plugin enforces correctness through a hooks layer and includes 14 complementary skills plus a router and validation enforcement.

WhoDB is a Claude Code plugin providing database management tools for querying, exploring schemas, analyzing data, and optimizing queries across PostgreSQL, MySQL, SQLite, MongoDB, Redis, ClickHouse, Elasticsearch, and more. It includes specialized agents for database analysis and query optimization, with configurable security modes and MCP server deployment via npm, Docker, or local binary.

A standalone agent skill that installs and manages opinionated Oxlint rules (the anti-slop plugin) into TypeScript/JavaScript repositories, including support for merging updates while preserving local customizations. The skill copies the vendored ruleset, installs compatible Oxlint versions, configures the linter, and optionally enables Effect-specific rules for projects that use Effect.

CCX is a standalone Agent Skill pack for managing AI API proxy deployment workflows in Claude projects, with four skills covering model registration, Windows Store publishing, upstream version tracking, and semantic versioning. The skills automate updates to routing configuration, MSIX validation and Store announcements, upstream change detection with TODO generation, and git-based version bumping with auto-generated changelogs.

A comprehensive MCP server providing 37+ tools for AI assistants to control DaVinci Resolve Studio via the official Scripting API, with live and offline support for editing, grading, conforming, Fusion, Fairlight, delivery, and media analysis. Includes 15 specialized Agent Skills (house-style, release-check, resolve-audio, resolve-color, resolve-conform, resolve-delivery, resolve-edit, resolve-fusion, resolve-mcp, resolve-media-analysis, resolve-media-pool, resolve-rough-cut, resolve-session, resolve-tighten-recording, docs) that self-trigger on domain-specific workflows and route to appropriate tools.

This Claude Code plugin bundles 14 Agent Skills for building and deploying applications on Cloudflare's platform, including guidance for Workers, Durable Objects, Sandbox, Agents SDK, and infrastructure tools like Wrangler and Email Service. It also includes the Cloudflare MCP server for direct API access and developer documentation integration.

Pro Workflow is a complete AI coding system with self-correcting memory, persistent SQLite-indexed research wikis, and an auto-research loop that learns from corrections across sessions. It provides 41 skills, 8 agents, 23 commands, and intelligent hooks that inject relevant knowledge and enforce quality gates without requiring API keys or external services.

This plugin provides 9 skills and an AWS knowledge MCP server for building, deploying, and operating AI agents on AWS using Amazon Bedrock AgentCore, LangGraph, and Strands. It covers the full agent lifecycle including scaffolding, memory management, tool integration via Gateway, multi-agent orchestration, Cedar access policies, evaluation, observability, and production hardening.

This Claude Code plugin integrates AWS DevOps Agent and AWS Security Agent to investigate incidents, review code for release readiness, scan for vulnerabilities, and run penetration tests. It provides 13 skills and 9 commands for automating security and operational workflows across multiple AWS accounts and agent spaces.

The aws-core plugin equips Claude with 25 curated skills and the AWS MCP Server to build, deploy, and manage applications across AWS services including compute, databases, messaging, observability, and cost optimization. It provides authenticated access to 300+ AWS services via the managed MCP server while also supporting infrastructure-as-code (CDK, CloudFormation), serverless development, and Well-Architected Framework reviews.

This Claude Code plugin provides 13 agent skills and an MCP server for building and operating end-to-end data workflows on AWS, covering data lake creation (S3 Tables, Iceberg), ingestion from multiple sources (JDBC, Snowflake, BigQuery, DynamoDB), querying (Athena, federated catalogs), and orchestration (Amazon MWAA DAGs and Serverless workflows). It includes capabilities for data discovery across AWS Glue Data Catalog, vector storage with Amazon S3 Vectors, Amazon OpenSearch Service provisioning and search, Amazon Redshift SQL execution, and MWAA environment management including Airflow version upgrades.

This plugin brings AWS Startup Solutions Architects' patterns directly into Claude, offering stage-aware architecture advice, guided building flows, AI agent runtime selection, and phased migrations from Azure/GCP/Heroku to AWS—including LLM stack rewrites to Amazon Bedrock. It includes 11 skills covering architecture review, infrastructure scaffolding, cost planning, Terraform quality gates, and access to AWS Activate credits and 60+ startup partner offers.

Official Expo plugin providing 24 AI agent skills for building, deploying, upgrading, and debugging Expo apps across React Native, iOS, and Android, with clear separation between open-source framework skills and paid Expo Application Services (EAS). Connects to mcp.expo.dev and includes navigation, animations, design systems, data fetching, native modules, App Store submissions, EAS Build/Update/Observe, and remote simulator capabilities.

Two standalone Agent Skills for Supabase development: the comprehensive "supabase" skill covers all Supabase products, client libraries, auth workflows, and the CLI; "supabase-postgres-best-practices" provides Postgres optimization and schema design guidance across query performance, connection management, security, and advanced features. Both skills integrate with Supabase's MCP server and are installable via `npx skills add` or as Claude Code plugins.

This plugin adds transparent cloud storage operations to Claude Code by integrating Box CLI, automatically syncing file changes to Box via hooks while providing a skill that teaches agents safe, guardrail-aware Box operations like versioning, conflict detection, and narrow-default sharing. It works with any Box account (personal, business, or enterprise) and includes explicit operation modes for searching, downloading, uploading, and sharing files while preventing unsafe patterns like duplicate creation and public-by-default sharing.

Claudebase backs up and restores your entire Claude Code environment—including agents, skills, hooks, rules, and memory—to a private GitHub repository with multi-machine conflict detection and timestamped backups. It supports switching between named profiles (work, personal, team), secret scanning to block API keys and tokens, and dry-run previews before syncing configuration changes.

Five live-detection skills for Databricks workspace diagnostics—cost-leak-hunter, cluster-forensics, uc-migration-pilot, streaming-guardian, and bundle-medic—that run real queries and API calls against your workspace via the databricks-workspace-mcp server. Each skill audits specific Databricks components (billing, cluster events, Unity Catalog readiness, streaming health, and asset bundles) and degrades to advisory mode when the MCP is unavailable.

This plugin detects which flavor and mode of Dolt database you have (classic Dolt, Doltgres, DoltLite, or DumboDB, running as repo/server/embedded/file), then routes version-control work through the dolthub/dolt-mcp server with a safety gate that keeps destructive operations (push/merge/reset/branch-delete) recommend-only. It ships with five expert agents for sync advisement, epic auditing, dependency mapping, incident recovery, and Dolt expertise, plus a beads task-tracker adapter.

This GitHub Actions plugin automates secure CI/CD workflows for Google Cloud and Vertex AI deployments, enforcing Workload Identity Federation (WIF) for keyless authentication and comprehensive security best practices. It provides pre-commit validation hooks, post-deployment health checks, and IAM least-privilege enforcement to ensure production-ready pipelines.

j-rig is a Claude Code plugin that implements an eval-guided improvement loop for SKILL.md files using a thin wrapper over the @intentsolutions/refiner CLI package. It provides a 3-layer cost-tiered hook architecture (sinker/line/hook) that validates skill edits, captures rollouts, and gates commits with agentic checks to ensure only improvements with no regressions are applied.

This plugin automates changelog generation by collecting recent changes from GitHub, Slack, and Git, synthesizing release notes, validating structure/quality, and preparing a PR. It uses a hybrid Skill + MCP workflow with three commands for validating and generating weekly or custom-date-range changelogs.

This Claude Code plugin automatically formats markdown files in your workspace using prettier whenever Claude stops responding, triggered by a Stop hook with configurable organization and path exclusions. It runs asynchronously in the background with zero configuration required, supporting custom exclusions, optional AI-generated commit messages, and comprehensive logging.

Sugar is a Claude Code plugin that adds persistent memory, cross-session context, and autonomous task execution to AI-assisted development workflows. It discovers work from error logs and GitHub issues, manages tasks in a SQLite backend, and coordinates autonomous development through specialized agents.

Tonone is an open-source AI team of 100 specialist agents that installs into Claude Code, covering engineering, product, operations, design, security, and data science disciplines to enable solo founders to run company-scale work. It provides 189 skills organized around 31 specialized agents across infrastructure, backend, frontend, ML/AI, security, DevOps, observability, and compliance domains, executable through slash commands and markdown workflow documents.

This plugin provides DAG-based workflow orchestration with 4 MCP tools that enable users to define, execute, and track complex multi-step workflows with dependency management and parallel task execution. It requires Node.js and offers features like real-time status monitoring, comprehensive run history, and graceful error handling.

x-bug-triage-plugin is a closed-loop bug triage pipeline that ingests X/Twitter complaints, clusters them, scans for repository evidence, routes to owners, and files GitHub issues with human confirmation at each step. It provides a terminal-driven CLI interface with a single MCP server (19 tools) orchestrated by Claude agents, requiring only bun, an X API token, and GitHub credentials.

Shunt redirects large file reads and code generation to AiKA delegation modes through the Portal CLI, saving 82-94% of tokens by blocking I/O-heavy operations before they enter Claude's context. It uses hooks to intercept file reads over 350 lines and delegates to preconfigured bulk-reader and code-writer modes that handle the work autonomously.

This Claude Code plugin provides integration with Stripe's development capabilities through MCP, enabling developers to interact with Stripe APIs directly within Claude. It includes 10 skills, 1 agent, and 2 commands for managing Stripe operations, with shell execution support and multiple hook points for workflow automation.

pg-aiguide provides AI coding assistants with 9 curated PostgreSQL best-practice skills covering spatial tables (PostGIS), TimescaleDB hypertables, vector search, hybrid text search, and database migration patterns. It works as installable Agent Skills, an MCP server, or a Claude Code plugin with semantic search over PostgreSQL, TimescaleDB, and PostGIS documentation.

A PreToolUse hook that intercepts and blocks destructive git and filesystem commands (like `rm -rf`, `git reset --hard`, `git push --force`) before execution by parsing command semantics rather than simple patterns, so flag reordering and shell wrappers cannot bypass it. It runs on Windows, macOS, and Linux across seven coding agent CLIs including Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi.

This plugin integrates the Azure MCP Server and 38 curated Azure skills to enable Claude Code agents to manage Azure infrastructure, deploy resources, and troubleshoot cloud services with structured decision-making and guardrails. It provides 200+ tools across 40+ Azure services including deployment workflows, diagnostics, cost optimization, AI/ML, identity management, and Foundry integration.

CC Safety Net intercepts and analyzes shell commands before execution, blocking destructive operations (like `git reset --hard`) and secret file access (SSH keys, `.env` files) by parsing command intent rather than string matching. It runs as a PreToolUse hook on node and works across multiple coding agent CLIs including Claude Code, Cursor, and GitHub Copilot CLI.

This plugin integrates Azure MCP Server, enabling access to 40+ Azure services through Azure CLI authentication directly within Claude. It provides command, skill, and MCP server components to manage Azure resources programmatically.

This Claude Code plugin synchronizes CLAUDE.md documentation and a permissions allowlist with an external Python script, then refreshes context on demand via a PostToolUse hook. It provides four commands to manage plugin metadata and permissions without requiring external API keys.

This plugin provides an MCP server interface to Google Cloud's observability suite, enabling access to logs, metrics, and traces through Claude. It bundles best practices for monitoring and troubleshooting applications running on Google Cloud Platform.

This plugin provides Git and GitHub workflow automation through 4 agents and 7 skills, handling commits, pull requests, code reviews, and comment resolution with built-in safety hooks. It integrates validation tools for commit types, visual proof requirements, and AI attribution checks directly into your development workflow.

This plugin provides Ultralytics Platform API integration and YOLO26 training skills for Claude Code, with pre/post-tool-use hooks and a push guard that blocks force pushes via Python. It enables direct interaction with Ultralytics services and model training workflows while enforcing safe git practices.

This plugin provides web performance audits by integrating Core Web Vitals metrics and Chrome DevTools analysis into Claude workflows. It includes a skill and MCP server for analyzing page performance and generating optimization recommendations.

The salesforce-development plugin provides AI-powered Salesforce platform development in Claude Code, auto-detecting your environment and injecting org context to enable natural-language creation of Apex code, metadata, flows, deployments, and security configurations. It combines 37 skills, the Salesforce CLI, and Salesforce-hosted MCP servers to resolve capabilities across metadata, deployment, reporting, and org lifecycle management.

This Claude Code plugin provides end-to-end build, test, deploy, and inventory workflows for Power Apps component framework (PCF) code components targeting model-driven apps, Power Pages, and canvas apps, with guided setup and Microsoft-maintained templates. It requires Node.js 20+, PAC CLI, .NET SDK, and Azure CLI to run local scaffolding, deployment, and verification tasks.

This plugin scaffolds and deploys Power Apps mobile applications using Expo and React Native, enabling developers to build native mobile experiences that connect to Power Platform data through Microsoft's native host package. It automates app generation, screen design, native capability configuration, and connector wiring via agent-driven skills that integrate with Azure authentication and Entra app registration.

The model-apps plugin builds and deploys complete model-driven Power Apps end to end, with /app-builder generating whole apps (tables, relationships, forms, views, charts, security roles) from natural language and /genpage creating generative pages using specialist agents for planning and parallel code generation. It requires PAC CLI > 2.10.0, Azure CLI, and Node.js LTS, integrating with Power Platform via the vendored cds-maker-sdk and leveraging feature flags for experimental capabilities like custom API calls and telemetry.

Build, edit, run, and debug Power Automate cloud flows directly from Claude Code using the FlowAgent MCP server, with support for surgical edits, environment copying, run management, and expression validation. The plugin runs offline with a self-contained MCP engine and uses local Azure CLI authentication, requiring only Node.js 18+.

A comprehensive Claude Code plugin for creating and deploying Power Pages code sites (SPAs) using React, Angular, Vue, or Astro, with integrated workflows for data modeling, backend integration, authentication, and ALM orchestration. The plugin provides 35 AI-driven skills covering the full lifecycle from scaffolding and development to deployment, testing, and cross-platform migration, leveraging Node.js, PAC CLI, and Azure CLI.

This plugin tints a Terminal.app window with project-specific colors during Claude Code sessions and brightens the window when a response arrives while unfocused. It uses hooks to intercept commands like `,api` to tag sessions and track their state without invoking the model.

craftsman is a Claude Code plugin that enforces minimal-diff coding, root-cause debugging with recurring-bug detection via graphify, and environment-quirk memory across sessions. It provides ten agents, seven skills, two slash commands (/craftsman:init and /craftsman:quick), and a cross-platform hook system to ensure honest completion reports and ask-before-writing project scaffolding.

ForkMind treats AI conversation context windows like Git repositories, enabling you to capture, branch, and regression-test LLM calls as a directed acyclic graph. It runs locally via Ollama or OpenAI-compatible APIs, with an integrated MCP server that lets agents query their own conversation history for debugging and comparison.

This plugin guides developers through integrating Amazon Location Service features like maps, geocoding, routing, and place search into their applications via Claude Code. It provides authentication setup, SDK integration patterns, and best practices through an MCP server connection to AWS.

This plugin orchestrates AWS Amplify Gen 2 full-stack development through guided, phased workflows that handle authentication, data models, storage, APIs, and deployments. It provides an MCP server for AWS documentation retrieval and validates prerequisites, then executes only the applicable phases based on user requests.

This plugin provides 7 skills for designing, building, deploying, testing, and debugging AWS Serverless applications using SAM and related tools. It includes an MCP server and shell integration for hands-on serverless development workflows.

AWS Transform is an AI-powered code modernization service that migrates codebases to AWS, covering .NET Framework to .NET 8/10, mainframe COBOL to Java, VMware VMs to EC2, SQL Server/Oracle/MySQL to Aurora, and language/SDK upgrades. The plugin integrates AWS Transform's assessment, planning, and execution workflow into Claude coding agents with workload-specific guidance and just-in-time authentication.

This plugin provides expert guidance on the AWS database portfolio, helping developers design schemas, execute queries, and choose the right database for their workload. It leverages MCP servers and AWS knowledge integration to assist with database design and migrations.

This Claude Code plugin analyzes codebases and generates AWS infrastructure deployments with cost estimates, CDK/CloudFormation IaC, and draw.io architecture diagrams using official AWS4 icons. It connects to three AWS MCP servers for real-time pricing data, IaC best practices, and architecture guidance.

This plugin brings 19 deep AWS SageMaker AI skills to Claude Code for end-to-end model customization workflows and HyperPod cluster operations, from fine-tuning foundation models to advanced debugging across training infrastructure. It connects to AWS services via the aws-mcp MCP server for documentation and standard operating procedures retrieval.

This MCP plugin connects Claude to Sentry for error tracking and performance monitoring via the Sentry MCP server. It enables Claude to query and analyze error reports, performance issues, and application health data directly within code and agent workflows.

This Claude Code plugin integrates Sentry error monitoring and performance tracking into your development workflow through an experimental MCP server. It provides access to Sentry's project management, issue tracking, and debugging capabilities via Claude.

Unbrowse replaces WebFetch, WebSearch, and browser MCPs with a hosted cloud browser MCP that supports scraping, discovery, and saved logins via hooks that intercept tool use and session start. The plugin requires authentication via OAuth or API key and redirects browser operations to Unbrowse's cloud endpoints instead of local tools.

Recall maintains fully-local session memory for Claude Code by logging activity to `.recall/history.md` and auto-summarizing it with a local TF-IDF + TextRank algorithm into `.recall/context.md`—no external APIs, no model calls, no data leaves your machine. Each new session can resume from the saved context, eliminating the need to re-explain the project and stretching your subscription's token budget.

Reticle is a Claude Code plugin that installs a skill and registers an MCP server enabling agents to visually inspect, interact with, and assert against a running web application from within the development environment. It provides capabilities to look at the app's current state, perform actions on it, observe changes, and validate behavior against expectations.

capcut-cli allows Claude Code to create and edit CapCut and JianYing projects directly from the command line, supporting subtitles, SRT/ASS import, timing, speed, volume, keyframes, masks, filters, effects, templates, linting, preview rendering, and conversion of long-form content to shorts. The tool works on local draft files with no external APIs or servers required, and outputs fully editable projects that can be opened and further refined in CapCut or JianYing.

This plugin exposes local services via secure tunnels, enabling creation of public HTTPS, TCP, and UDP URLs for webhooks, demos, and AI agent workflows. It wraps the rustunnel CLI and MCP server to manage tunnels, peer-to-peer connections, and load-balanced pools directly from Claude Code.

This plugin provides programmatic access to Adobe Premiere Pro projects via an MCP server, enabling inspection, editing, verification, and export of local projects. It integrates with Premiere Pro through a local bridge that exposes project data and operations to Claude.

A specialized Claude Code plugin providing 26 agents and 51 skills for Elixir, Phoenix, and LiveView development with Iron Laws verification and Tidewave MCP integration. The plugin enforces development guardrails through hooks and shell-based tooling for safety checks, dependency auditing, and intelligent task routing.

Ralph Speckit enables spec-driven development in Claude Code using the GitHub spec-kit methodology, guiding projects through constitution-first phases: specify, plan, tasks, and implement. The plugin manages feature branches, state persistence, parallel task execution, and autonomous implementation via a stop-hook loop with built-in QA verification.

ralph-specum enables spec-driven development by decomposing feature requirements into executable tasks, with research, design, and autonomous implementation phases. It orchestrates multi-spec workflows through 16 commands, 10 agents, and hooks that coordinate spec context loading and task execution guards.

This Claude Code plugin exposes hundreds of Unreal Editor tools via MCP, including actors, blueprints, materials, Niagara, Control Rigs, Sequencer, State Trees, Gameplay Ability System, and automation testing. It requires Unreal Editor with ModelContextProtocol and AllToolsets plugins enabled, and runs a SessionStart hook to inject project context into Claude's understanding of UE conventions.

The dxos plugin integrates DXOS Composer as an MCP server for Claude Code, enabling durable project and task tracking via `/dxos:project` command and QA test execution via `/dxos:qa`. It maintains a committed registry of work-streams and per-project TASKS.md ledgers, with optional cloud backend support through a Composer account with passkey authentication.

Auto-stage hooks into Claude Code's Edit|Write operations to automatically run `git add` on every modified file, keeping git status synchronized with Claude's changes. The hook respects .gitignore, runs shell-free to prevent command injection, and logs all staging outcomes without requiring manual intervention.

This Claude Code plugin installs a PreToolUse hook that blocks dangerous Bash commands (rm targeting home/root directories, fork bombs, curl|sh, force pushes, git reset --hard, chmod 777, docker volume rm, etc.) before they execute. Three configurable safety levels (critical/high/strict) control what gets blocked, with per-level ask mode allowing you to approve or reject matches instead of hard-denying them.

cache-tax warns developers before their next message triggers a costly prompt cache rewrite after the 1-hour cache window expires, showing the dollar cost upfront via a UserPromptSubmit guard and SessionStart hook. It also renders a status-line segment displaying cache countdown, rewrite costs, and session statistics without requiring a separate plugin installation.

This PreToolUse hook intercepts destructive Bash commands (rm, rmdir, mv, mkdir, touch, find) and blocks or prompts when the target path differs only in case from what exists on case-insensitive filesystems like APFS and NTFS. It properly resolves command context through cd chains, subshells, quotes, and shell connectors without making probe filesystem calls.

A PreToolUse hook that prevents agents from modifying guardrail configuration files (settings.json, hooks.json, .mcp.json, plugin manifests, and optionally instruction files) across Bash, Edit, MultiEdit, and Write operations by deny-by-default filtering. The hook logs all decisions locally and supports three safety levels (critical, high, strict) with optional prompt-instead-of-deny modes.

This Claude Code plugin tracks per-file context costs by hooking into tool results and attributing tokens to the files they loaded, then renders a leaderboard of your repo's most expensive files at session end or on demand. It uses local byte-to-token estimates (~4 bytes/token) and configurable pricing to help developers identify which files consume the most context.

This PostToolUse hook automatically formats Python files with ruff and JavaScript/TypeScript/JSON/Markdown/YAML/HTML files with prettier immediately after Claude writes or edits them. File paths are passed safely via argv to prevent shell injection, unsupported files are skipped silently, and all outcomes are logged to ~/.claude/hooks-logs/.

git-safety is a PreToolUse hook that prevents destructive git and GitHub CLI operations in Claude Code by denying branch-unsafe commands (commits/pushes/merges on main/master) and risky gh operations before they execute. It runs synchronously at configurable safety levels (critical/high/strict) and logs every blocked command locally without network calls.

guard-pack bundles seven security and safety hooks (spawn limits, config protection, dangerous command blocking, secret protection, test isolation, git safety, case sensitivity) into a single Node process that runs on tool calls. It evaluates guards in a fixed order with the first blocking verdict winning, and includes detailed logging to ~/.claude/hooks-logs/ while making no network calls.

nerf-receipts is a local telemetry plugin for Claude Code that passively records per-session signals (tool-failure rate, edit churn, turn counts, tokens-per-task) keyed by model version, then renders trend cards with sparklines to detect statistically meaningful shifts when a model changes. All data stays on your machine—it records only counts and file paths, never tool inputs, commands, or transcript text.

A PreToolUse hook that screens every Read, Edit, Write, and Bash call against tiered patterns to block or prompt on attempts to access or exfiltrate sensitive files (.env, SSH keys, cloud credentials, keystores) and dangerous shell commands. Matches are denied or converted to a prompt with the exact pattern id and reason, with tunable safety levels (critical/high/strict) via the HOOK_SAFETY_LEVEL environment variable.

This plugin embeds a reviewer-facing provenance receipt into PR bodies when Claude runs `gh pr create` or `glab mr create`, recording tool calls, agent-authored lines, and test commands with exit codes. A PostToolUse hook maintains a per-session ledger, while a PreToolUse hook rewrites the PR body to include real prompt count, estimated spend, test tally, and agent-vs-human authored-line split.

Logs every Claude Code session as a durable markdown note with timestamps, file edits, and bash commands (secret-redacted), using three lifecycle hooks to seed, append, and finalize the record. Supports cross-device sync by writing to an Obsidian vault or iCloud folder via the CC_SESSION_LOG_DIR environment variable.

The astronomer-data plugin bundles an Airflow MCP server and 34 specialized skills for data engineering workflows, enabling AI agents to explore data warehouses, author pipelines, manage DAGs, and run SQL-based analysis through a background Jupyter kernel. It integrates with Claude Code, Cursor, and other agentic coding tools, supporting both open-source and Astronomer-hosted Airflow deployments.

AgentOps provides DevOps discipline for AI coding agents through behavior-driven planning, shared domain language, and independent validation using a Plan-Implement-Validate loop. It includes 30 reusable skills, 4 agents, and tool-call guards to help agents produce consistent, well-tested work aligned with stated intent.

agnix validates agent configuration files (CLAUDE.md, SKILL.md, hooks, MCP configs) against 414 rules covering Claude Code, Codex CLI, OpenCode, Cursor, Copilot, and other AI tools, with auto-fix capabilities included. It catches misconfigured skills, invalid formats, and multi-tool stack incompatibilities before they silently break agent workflows.

This Claude Code plugin provides workflow development tools through 5 agents and 51 skills for building automation and processing pipelines. It includes a SessionStart hook and shell execution capabilities to support complex workflow orchestration within Claude.

desktop-act provides cross-platform computer-use primitives (screenshot, click, type, scroll, launch_app) backed by OS-specific implementations: X11/Xvnc on Linux, native macOS APIs, and Win32 on Windows, with an autonomous act() loop driven via Claude CLI OAuth. The plugin exposes an MCP server with no API key required, handling multi-desktop pools on Linux and single-desktop leases on macOS and Windows.

This Claude Code plugin transforms Claude into a business operating system with 66 skills and 21 agents managing communications (WhatsApp, Email, Slack, Telegram), projects, AWS infrastructure, revenue (Stripe, RevenueCat), e-commerce (Shopify), marketing (Klaviyo, Meta, GA4, GSC), monitoring (Datadog, New Relic, OTEL), and voice services (Bland AI, ElevenLabs, Whisper). It includes an interactive command center dashboard (/ops), autonomous YOLO mode with parallel C-suite agents, specialized subsystems for A&R analysis (/ops:ops-ar), GTM planning, macOS diagnostics (/ops:ops-mac), smart home control (/ops:ops-home), UniFi networking (/ops:ops-unifi), and safety hooks for secret detection, destructive command blocking, and post-merge deploy auto-fix.

ClaudeForge is an automated toolkit for creating, maintaining, and syncing CLAUDE.md files across Claude Code projects with a hard 150-line cap, automatic chaining via sub-files, and embedded Karpathy behavioural guidelines. It provides lifecycle hooks (PostToolUse, Stop), three parallel audit skills for drift detection and dependency scanning, and slash commands for initialization, enhancement, and synchronization.

MemStack provides 130 battle-tested skills for Claude Code spanning deployment, security, databases, git workflows, and more, with skills auto-activating on demand through markdown-based commands and a Python-based MCP skill loader. The plugin includes 86 free skills built-in, with 44 additional Pro-exclusive skills available via license activation.

This standalone Agent Skill repo provides eight specialized skills for optimizing LLM workloads, benchmarking inference performance, and analyzing GPU kernel execution across CUDA, HIP, and AMD platforms. The skills cover optimization domains including Magpie-driven kernel evaluation, vLLM/SGLang/Atom benchmarking, local AI app integration, and inference tracing with TraceLens for detailed performance analysis.

Reins intercepts tool calls via pre/post hooks to block destructive actions, route high-risk operations to human approval, and maintain an immutable audit trail of all decisions. It protects against vulnerabilities covered in OWASP MCP, ASI, and Agentic Skills Top 10 threat models by analyzing commands before execution and logging outcomes to a local decision log.

Clawdcursor is a local MCP server that gives Claude Code safe control of the desktop across Windows, macOS, and Linux by compiling the screen into a UI map and acting on elements by stable ID rather than screenshots. It verifies its own actions, gates everything through a safety checkpoint, and serves as the fallback execution layer when APIs and CLIs aren't available.

This Claude Code plugin automates FedRAMP compliance authorization using Key Security Indicators (KSIs), continuous monitoring, and machine-readable policies synchronized from official FedRAMP documentation. It provides shell-based commands and hooks for compliance notifications to streamline the authorization process.

grc-loop is a Claude Code plugin that implements a Ralph-loop mechanism for iterative GRC workflows, driving `/grc-engineer:*` commands to automate gap remediation burndowns and quarterly evidence collection sweeps. It uses a state file watched by a Stop hook to repeat prompts until a completion criterion is met, stopping short of destructive operations and handling manual-only or uncollectable items gracefully.

NextBoard is a PCB hardware solution design agent that takes product requirements and outputs reviewable, implementable PCB schematics through a structured 7-stage workflow including requirement freezing, architecture selection, component sourcing, and multi-dimensional review. The agent automatically analyzes chip solutions, performs component selection, generates BOMs with pricing, creates module schematics, and produces comprehensive technical deliverables including markdown, datasheets, and PDF documentation.

A Claude Code Skill that generates programmatic videos using React components and the Remotion framework, with AI-powered text-to-speech audio (via MiniMax or Edge TTS) and scene-based timing. The skill scaffolds video projects with support for animations, subtitles, and music visualization.

mcp-devices provides mobile device automation CLI functionality for Android, iOS, HarmonyOS, Aurora OS, and Desktop platforms through an MCP server integration. It enables developers to automate interactions and control across multiple mobile operating systems without requiring external API keys.

SupaConductor is a multi-agent orchestration plugin for Claude Code that automates planning, execution, and quality checks to turn feature requests into completed code — coordinating 15 agents, 4 evaluators, and a "Board of Directors" across 39 commands and 42 skills. It handles task decomposition, parallel execution, code review, and automated fixes without requiring manual re-prompting or external service keys.

This Claude Code plugin integrates CodSpeed, a performance measurement and benchmarking platform, providing capabilities to measure code performance with <1% variance using CPU simulation and detect performance regressions. It exposes CodSpeed functionality through an MCP server connection, enabling performance optimization analysis directly within Claude Code.

Direct Chrome DevTools Protocol access for browser automation via a zero-dependency skill or lightweight MCP server, supporting 17 CLI commands across tab management, navigation, interaction, and content extraction. The plugin auto-starts Chrome on a dynamically allocated port, handles JavaScript dialogs and permission prompts transparently, and works across macOS, Linux, and Windows.

This plugin provides 31 Databricks skills for the Claude CLI, Apps, Lakebase, Model Serving, Lakeflow Jobs, Spark Declarative Pipelines, and Declarative Automation Bundles (DABs), along with utilities for classic-to-serverless migration. It requires Python and integrates via shell commands and hooks for session lifecycle and tool usage events.

Conserve is a Claude Code plugin that optimizes token usage and session efficiency through bloat detection, code quality auditing, and context window management following the Maximum Effective Context Window (MECW) principle. It provides commands for scanning dead code, remediating bloat, auditing AI-generated code patterns, and managing context compression across session boundaries.

Egregore is an autonomous agent orchestrator that manages full development lifecycles through a 16-step pipeline, handling session continuity, token budget management, and crash recovery without human intervention. It coordinates specialist skills (attune, pensive, sanctum, conserve) across work intake, build, quality, and ship phases while persisting state and recovering from failures via a watchdog daemon.

Leyline provides shared infrastructure and pipeline building blocks for Claude Code plugins, including quota management, error handling, authentication patterns, and service registry utilities. It enables cross-plugin communication and system stability through standardized patterns for resource tracking, rate limiting, and crash recovery.

Oracle is an ONNX Runtime inference daemon plugin that provides local ML model inference over HTTP with explicit opt-in activation through a dedicated Python 3.11+ virtual environment. The daemon runs isolated from the system Python and manages its own lifecycle via SessionStart and Stop hooks, requiring no external API keys or third-party services.

Sanctum automates Git and development workflows through preflight checks, conventional commit generation, PR preparation with quality gates, and version management. It also consolidates documentation, performs scope-focused code reviews, and improves workflows through session analysis and retrospectives.

This Claude Code plugin provides agent skills and a hosted MCP server for deploying, configuring, monitoring, and troubleshooting applications and infrastructure on Railway, including management of services, environments, deployments, databases, object storage, networking, and observability. It runs a shell-based hook before tool use and connects to the Railway MCP server at mcp.railway.com to enable Railway operations directly from Claude Code.

Sage is a lightweight security layer that intercepts tool calls (shell commands, URL fetches, file writes) and checks them against multiple threat detection layers including URL reputation, local heuristics, prompt injection detection, and supply-chain checks before execution. It integrates with Claude Code and other AI coding assistants via hooks that monitor PreToolUse, PostToolUse, and SessionStart events to prevent dangerous actions.

This Claude Code plugin provides AI agents with a relational knowledge graph of the Vercel ecosystem and a bundled skill library covering Vercel products, APIs, and workflows for building and deploying web applications. It includes 49 skills, 3 agents, commands, hooks, and an MCP server that integrate with mcp.vercel.com to enable deployment, authentication, caching, and infrastructure management.

ork is a comprehensive AI development toolkit providing 105 skills and 37 agents alongside 108 hooks and 35 commands for building full-stack applications with Claude Code. It requires only Node.js and integrates deeply into the Claude Code plugin lifecycle via multiple hook events.

This Claude Code plugin provides local, metadata-only telemetry that records session, tool, and subagent lifecycle events into SQLite on your machine, with optional integration to PostHog, Grafana, or generic OTLP endpoints through an OpenTelemetry Collector. All telemetry payloads exclude prompts, responses, code, tool inputs, credentials, and environment values, with every external sink strictly opt-in and configurable through local configuration files.

Quartermaster automates setup, health checks, and capability discovery for Claude Code projects by analyzing bounded session histories and proposing changes one at a time—all installations and edits require explicit approval. It manages Toolshed plugin installations, workspace configuration, and suggests missing skills or improvements based on accumulated work patterns, with local scripts protecting privacy by reducing transcripts to aggregated summaries before they reach the model.

This repo provides three Stata-related standalone Agent Skills—including stata-audit for inspecting and validating Stata-MCP audit logs, snapshots, and tool execution history, and stata-skill for general Stata integration. All skills work offline without external APIs or dependencies.

This plugin provides a specialized Playwright agent with MCP server integration for automating browser interactions and control workflows. It includes two skills and one MCP server to support best-practice browser automation patterns.

Maister provides structured, standards-aware development workflows for Claude Code through 25 agents and 17 skills that enforce best practices and safety guardrails. It includes pre-execution hooks to block destructive commands and shell reminders to keep developers aligned with workflow standards.

Guaardvark is a self-hosted AI studio plugin that integrates with Claude Code via MCP server, enabling local generation of images, videos, music, neural voice, and LoRA training—plus agent swarms, screen agents, knowledge RAG, and coding intelligence—all running on a single GPU. The plugin provides fifteen agent skills that let your coding agent queue media, training, and swarm jobs directly to your machine's GPU pipeline.

LeanKG is an enterprise-ready code knowledge graph built as a Claude Code plugin that integrates via MCP hooks to provide impact analysis, dependency tracking, code search, and context generation across multi-repo codebases. It reduces token usage by 65% and tool calls by 85% through structured indexing with Postgres/pgvector and exposes 85+ MCP tools for environment governance, incident tracking, and requirements traceability.

This Claude Code plugin provides comprehensive tooling for the Bun JavaScript runtime, including 27 skills covering testing, HTTP servers, WebSockets, databases, and framework integrations like Hono, Next.js, and SvelteKit. It includes 6 commands for project initialization, migration, debugging, optimization, and deployment, plus 3 agents for troubleshooting, performance analysis, and Node.js migration.

This plugin generates production-grade Python CLIs for closed-source web applications by automatically capturing and analyzing their HTTP traffic via browser automation. It uses Claude to exercise the app, map its API, and generate agent-ready command-line tools that can be installed and used immediately.

Claude Code plugin providing comprehensive guidance for implementing SEO in Nuxt 3/4 applications using all 8 official Nuxt SEO v5 modules, including robots.txt, sitemaps, Open Graph images, Schema.org structured data, and link checking. Covers installation, configuration, breaking changes, and troubleshooting across core and standalone modules with multi-language support.

Comprehensive Nuxt 4 development plugin with 4 focused skills (core, data, server, production) covering project setup, data fetching, server routes, and deployment, plus 3 diagnostic agents for debugging, migration, and performance optimization. Includes an interactive setup wizard and official Nuxt MCP integration for real-time documentation access.

Nuxt 5 development plugin with 4 focused skills (core, data, server, production), 3 diagnostic agents (debugger, migration, performance), and an interactive setup wizard. Includes official Nuxt MCP server integration for real-time documentation and handles Nuxt 5's major infrastructure changes including Vite 8, Nitro v3, and Web Standard APIs.

Claude Code plugin that packages 29 agentic skills for Meta Quest and Horizon OS development, powered by the metavr CLI and MCP server for device management, app debugging, performance analysis, and store submission workflows. Skills cover Quest app setup, Unity/WebXR integration, Spatial SDK, Platform SDK, and XR-specific debugging and optimization tasks.

Converts human-written SOPs into deterministic agentic workflows with static topology validation, bounded control flow, and typed field ownership contracts. Bundles three methodology skills (`six-rung-ladder`, `agentic-sop`, `agentic-workflow-audit`), a `/sop-flow` orchestration command, project-scoped regression gates via Stop-hook, and a portable `agentic-sop-kit` with built-in verification and cross-domain examples.

A linter and scaffolder for Claude Code plugins that validates manifests and plugin structure against a strict grammar, plus generates compliant plugin skeletons. It runs standalone using pure stdlib without external dependencies, checking manifest invariants, hook protocols, and test harness requirements.

Procoder is a Claude Code plugin that equips AI coders with 34 commands spanning nine domains (security, CI/CD, DevOps, GitOps, performance, maintainability, documentation, clean code, and best practices) plus a code index, enforcing quality gates through hooks that the agent cannot bypass. The agent stays in control while the plugin's binary computes findings—formatting violations, secrets, conflicts, lint issues, and test failures—and reports them for the agent to act on, never modifying code directly.

sd0x-dev-flow provides a comprehensive engineering harness for Claude Code with 16 agents and 100 bundled skills that enforce behavior-layer safety gates, pre- and post-tool review hooks, and fail-closed validation anchors. It operates across reminder-layer reviews, structured completion invariants, and risk-scaled audit tiers, while remaining compatible with Codex CLI, Cursor, Windsurf, and Aider via skills-only distribution.

This plugin provides 26 specialized skills and 12 MCP servers for data engineers working on Google Cloud, enabling natural language assistance for architecting data pipelines, writing dbt transformations, Spark and BigQuery SQL notebooks, creating Dataflow pipelines, and orchestrating end-to-end workflows across GCP's data ecosystem. It integrates with BigQuery, Spanner, BigLake, Dataproc and other Google Cloud data services, supporting medallion architecture patterns and workflow automation.

xclaude-plugin is a modular iOS development automation suite with 8 workflow-specific MCP servers (600–3500 tokens each) providing 23 tools for Xcode, Simulator, and IDB—enabling selective activation to keep context lean. It includes 8 procedural skills for xcode-workflows, simulator-workflows, ui-automation-workflows, accessibility-testing, ios-testing-patterns, crash-debugging, performance-profiling, and state-management.

A 14-agent Claude Code plugin that transforms raw code into production-ready systems by handling architecture, testing, security audits, CI/CD, and documentation across a structured DEFINE→BUILD→HARDEN→SHIP→SUSTAIN pipeline. The plugin's Loop Engine ensures agents iterate until convergence against verifiable checks like typechecking, tests, and running application validation rather than stopping at claimed completion.

This Claude Code plugin enables deployment of Docker Compose applications to your own cloud account through Defang integration, offering a /defang:deploy skill and MCP server support. It allows developers to deploy containerized applications directly from Claude without requiring external API keys.

The Dynatrace Claude Code plugin connects to your Dynatrace environment to investigate production issues, review deployments, and check vulnerabilities using 34 skills that cover DQL queries, observability (services, frontends, tracing, hosts, Kubernetes, cloud platforms), logging, problem analysis, and alerting. It includes an MCP server for live querying and optionally integrates with the Dynatrace CLI (dtctl) to execute workflows and create dashboards directly from Claude.

Compass is a local-first Rust workbench that analyzes codebases to generate architecture maps, dependency paths, impact analysis, and Git history—powers the compass-release skill for coordinating Compass version bumps, release PRs, and cross-platform artifact builds via a gated workflow.

MCP server that enables AI models to create and modify SAP Fiori applications through natural language prompts, with support for generating CAP projects, list report apps, and UI customizations. It integrates with Claude Code and other AI coding assistants to automate Fiori development tasks using tools like project generation, documentation search, and app modification capabilities.

Bridge compiles natural-language design descriptions into Figma output that is guaranteed design-system compliant by construction, enforcing 26 Figma API rules automatically through a local deterministic compiler. It provides Claude Code skills for iterative design generation (`make`/`fix`/`done`), maintains a synchronized knowledge base of design system registries via cron, and executes designs in Figma through MCP.

This plugin provides 18 best-practice skills for building stablecoin applications with Circle's USDC infrastructure, covering payments, cross-chain transfers, wallets, and smart contracts. It includes an MCP server for real-time integration with Circle's SDK and documentation.

Token-Saver is a Claude Code plugin that automatically compresses verbose CLI output from tools like git, docker, npm, pytest, and kubectl using 36 specialized processors, reducing token usage by 60–99% while preserving errors and actionable data. It runs transparently in the background on PreToolUse and SessionStart hooks, providing offline regex-based compression with no LLM calls or configuration required.

codeArbiter is an orchestration layer for Claude Code that routes all intents through gated skills and reviewer agents, mechanically enforces commit and audit-trail gates, and maintains an append-only audit log of all decisions via SMARTS. It requires Python 3 and operates on a per-repo basis, remaining dormant until explicitly activated with `/ca:init`.

This plugin automatically formats C# files using CSharpier after Claude writes or edits them, triggered by a PostToolUse hook that respects project-level .csharpierrc configuration. It handles multiple C# file extensions, survives CSharpier version upgrades, and can be disabled via environment variable without affecting other .NET functionality.

This plugin provides a suite of .NET development tools including automatic CSharpier code formatting for C# files, dotnet-run-file for executing C# without projects, and skills for code analysis via Roslyn AST queries, API inspection, and code coverage reports. It hooks into Claude's post-edit workflow to format C# files automatically and exposes 9 skills for inspecting .NET libraries, analyzing code patterns, and diagnosing style violations.

This plugin provides a Playwright MCP server that integrates browser automation and QA testing capabilities, exposing tools to navigate pages, take screenshots, interact with elements, and fill forms across Chromium, Firefox, and WebKit. It requires npx to run the Playwright-based MCP server for automated testing and web interaction workflows.

Adds Logfire observability and monitoring to Python applications with auto-instrumentation for FastAPI, httpx, asyncpg, SQLAlchemy, and other frameworks, plus interactive querying and UI access to traces, logs, and metrics. The plugin includes commands for detecting frameworks and instrumenting code, skills for setup and infrastructure monitoring, and an MCP server for querying Logfire data.

EvalView is a snapshot testing framework that records AI agent behavior (tool calls, parameters, order) and detects regressions via baseline diffing, supporting LangGraph, CrewAI, and multiple LLM providers. It integrates with CI/CD pipelines to gate PRs on behavioral changes and works offline for deterministic tool-sequence diffs.

This plugin enables Claude to monitor and interact with Unraid NAS/homelab systems via an MCP server, requiring local Unraid API credentials and configuration. It provides real-time visibility into your Unraid infrastructure through Claude's interface with no reliance on external paid services.

This plugin connects Claude to Unraid servers via GraphQL API, enabling querying and management of system info, Docker containers, VMs, array status, plugins, and live telemetry through MCP tools. It requires an Unraid API key and URL to authenticate and communicate with the server.

This Carbium skill provides drop-in infrastructure for building on Solana with bare-metal RPC, WebSocket pubsub, gRPC full-block streaming, sub-millisecond DEX quotes via CQ1 engine, gasless swaps, and MEV-protected execution through Jito bundling. It replaces Helius, QuickNode, Triton, and Jupiter Swap API for Solana developers.

This Solana vault management skill enables DeFi operations through the GLAM Protocol, supporting vault creation, asset management, staking, and cross-chain transactions via CLI and TypeScript SDK. It integrates with protocols like Jupiter, Kamino, Marinade, and others to handle tokenized vaults, delegation, and NAV-based subscription/redemption flows.

This Solana trading skill integrates DFlow trading APIs with Helius infrastructure to enable spot swaps, prediction markets, and real-time market streaming for automated trading applications. It provides comprehensive transaction submission, wallet intelligence, and fee optimization features including shred-level streaming via LaserStream and Proof KYC verification.

This standalone Agent Skill provides comprehensive access to Quicknode blockchain infrastructure across 80+ chains, including Solana RPC endpoints, DAS API for NFT/token querying, Yellowstone gRPC streaming, priority fee estimation, and Jupiter swap integration via Metis. Install with `npx skills add` to enable interactions with Quicknode's real-time data pipelines, webhooks, IPFS storage, and pay-per-request RPC services.

Surfpool is a complete development environment for Solana programs that replaces solana-test-validator with mainnet forking, cheatcodes, and Infrastructure as Code capabilities. It provides the fastest way to develop and test Solana smart contracts with Surfpool Studio included.

Alive provides local, user-owned context management for Claude Code, enabling you to keep all your work in files you control on your machine. It integrates through multiple lifecycle hooks and shell execution to maintain persistent session state across tool use and user interactions.

Ultraship is a Claude Code plugin with 45 skills, 13 agents, and 37 audit tools for building, shipping, and scaling production software—covering accessibility (WCAG 2.2), security scanning, code quality, SEO, AI readiness, and bundle analysis. A built-in Currency Guard keeps Claude on current docs rather than stale training data, with a blocking ship-gate scorecard that runs six parallel audits (SEO, accessibility, secrets, code profiling, bundle tracking, env validation) before deployment.

This Claude Code plugin provides persistent memory for sessions through a local Honeycomb daemon, enabling Claude to retain context across interactions without external API dependencies. It integrates via lifecycle hooks and an MCP server to automatically save and recall session state.

MalChela is a Rust-based malware analysis toolkit that exposes file analysis, YARA rule scanning, hash lookup, NSRL queries, and directory scanning through an MCP server for Claude integration. It supports Windows PE analysis, macOS Mach-O inspection, string extraction with MITRE ATT&CK mapping, and multi-source threat intelligence queries.

Alfred Dev is a software engineering automation plugin that orchestrates the development lifecycle with 10 specialized agents (8 core plus conditional frontend and on-demand agents), persistent project memory, and quality gates across product, architecture, development, QA, security, and deployment phases. It detects project stacks and adapts artifacts to Node.js, Python, Rust, Go, Ruby, Elixir, Java, PHP, C#, and Swift ecosystems with built-in EU compliance (GDPR, NIS2, CRA) and verification gates before each phase transition.

Double Shot Latte is a Claude Code plugin that intercepts stop attempts and uses a separate Claude instance to intelligently decide whether Claude should continue working instead of asking for permission. It analyzes conversation context to determine if work is incomplete and next steps are obvious, blocking unnecessary interruptions while respecting legitimate stops.

This Claude Code plugin verifies changes work by driving the real system the way a user does, using acceptance criteria derived from your plan rather than the implementation. It boots your full stack, runs browser and API tests against real infrastructure, and generates a detailed report with evidence for every check.

A Claude Code plugin providing three consolidated skills for the complete Agentforce agent lifecycle: authoring agents via Agent Script DSL, testing with safety probes and execution validation, and observability through production session analysis. The plugin integrates LLM-driven safety reviews across development, deployment, testing, and optimization phases.

A Model Context Protocol (MCP) server that enables AI-assisted development of SAP Cloud Application Programming Model (CAP) applications through semantic search over CDS model definitions and CAP documentation. It provides tools to query entities, services, and HTTP endpoints in CAP projects, as well as locally-embedded vector search through preprocessed CAP docs.

ALDC is an AI-native development toolkit for Microsoft Dynamics 365 Business Central that provides 5 specialized agents, 10 workflows, and 15 knowledge skills for extension development with test-driven development, architecture reviews, and human-in-the-loop gates. The plugin integrates event-driven architecture patterns, automated code generation, and TDD orchestration through a conductor agent that manages the full spec-to-review cycle.

This plugin turns a single Claude Code session into a project manager that launches and controls other Claude Code, Codex, or Pi sessions as parallel workers via tmux, monitoring their progress through JSONL event streams. Workers execute tasks independently and concurrently while a controller session assigns work, observes execution, and collects results.

VGV Wingspan is an AI-native workflow plugin that orchestrates a four-phase development cycle—brainstorm, plan, build, and review—with specialized agents and skills following Very Good Ventures best practices. It integrates code generation, testing, quality review, and PR management into a structured agentic system designed to work alongside the Very Good AI Flutter Plugin for production-grade output.

accesslint provides five web accessibility skills for Claude Code to audit WCAG 2.2 conformance, scan pages with rule engines, and run keyboard and screen-reader checks. It includes an MCP server and uses npx to perform hands-on accessibility testing, fixing violations, and catching regressions in CI pipelines.

AutoCode is a 47-skill Claude Code plugin powered by I-Lang v3.0 that automates the entire development-to-deployment pipeline in a single session, requiring only natural language instructions and bash. It handles server setup, application building, and live deployment with zero external dependencies, making full-stack development accessible to non-programmers.

great_cto orchestrates a pipeline of 69 specialist agents that design, build, review, and deploy full-stack applications with two human approval gates. Users describe a product once, approve the architecture, then approve the deployment while agents handle all intermediate stages including backend, frontend, testing, code review, and security.

Pith automatically compresses Claude Code tool outputs (file reads, bash runs, grep results) by 40–60%, tracking token usage with a status dashboard and enforcing context ceilings via hooks. It includes a self-building project wiki, symbol extraction, URL ingestion, and structured output modes that escalate from lean to ultra as context fills.

This Claude Code channel polls squirrelscan cloud audit events (audit completion, failures, and issues) and pushes them into your session so your agent can retrieve reports and fix detected issues. It requires the squirrel CLI with the channel command and an active squirrelscan login.

Monte Carlo Agent Toolkit brings data observability into Claude Code, surfacing blast radius, active alerts, and monitor coverage gaps before dbt edits via an MCP server connection. It provides skills for incident response, proactive monitoring, storage cost analysis, and push ingestion, with hooks that enforce data-safety checks automatically during development.

This Claude Code plugin integrates oxlint-tailwindcss linting into the editor, providing real-time diagnostics as Claude edits files and running a final lint check before completion. It includes an LSP server for inline diagnostics, hooks to capture and validate edits, and a setup skill.

This plugin provides four development workflow skills for planning, implementing, and containerizing cloud-native applications: a PRP generator for writing Product Requirement Plans with validation gates, an executor for driving feature implementation, a containerizer for modern Docker multi-stage builds and Compose setup, and a fifteen-factor app architecture reviewer. It integrates with GitHub and automatically picks up skills during sessions to guide development lifecycle decisions.

The Documents Toolkit plugin provides fast PDF text extraction, OCR for scanned PDFs, and structured parsing of PDFs and office files (DOCX, PPTX, XLSX, ODF, EPUB, email) into JSON and markdown. It includes uv-runnable scripts for PDF forms, table extraction, merging, splitting, and validation—all with zero local installations via uvx and inline dependencies.

This Claude Code plugin provides a comprehensive Google Tag Manager reference covering container setup, tags, triggers, variables, data layer management, and debugging, plus an MCP server that connects to Stape's GTM API for programmatic container management and publishing. Users can implement GTM tracking, configure server-side tagging, debug tracking issues, and automate tag operations through Claude Code with Google OAuth authentication.

This plugin enables Claude Code to manage MikroTik routers and automate network operations over SSH by hooking into session startup to prompt for router credentials. It wraps the mcp-server-mikrotik MCP server, storing the password securely in your system keychain and passing credentials via environment variables.

This Claude Code plugin integrates n8n workflow automation by exposing n8n workflows and executions through an MCP server. It requires an n8n instance URL and API key, stored securely in your system keychain, and launches via an MCP server that hooks into Claude Code's session start.

Ship is an agentic development harness that routes Claude or Codex through mechanically enforced quality gates—from raw requirements to green PR—making failure modes like skipped tests and unvalidated code structurally impossible. It provides 11 atomic skills (design, dev, E2E, review, QA, refactor, handoff, and more) that work standalone or as a full staged workflow with isolated phases, disk-resident state, and hierarchical evidence requirements.

This Claude Code plugin enforces a security boundary around a project directory, allowing destructive file operations (rm, mv, cp, etc.) and file edits within the project while blocking them outside. It uses bash hooks to parse and validate commands before execution, handling edge cases like symlinks, cd tracking, command substitution, and variable expansion.

This plugin integrates PostHog analytics, feature flags, experiments, error tracking, and insights directly into Claude Code through an MCP server, with optional session capture to PostHog LLM Analytics. It provides 27+ tools bundled with 30+ task-specific skills covering HogQL queries, A/B test management, feature flag operations, data warehouse setup, and SDK instrumentation.

The envault plugin intercepts tool calls via a PreToolUse hook to substitute secret aliases and ciphers into plaintext values, keeping sensitive data encrypted until the moment of use. It pairs with the envault CLI and the guard.sh external tool to provide a secrets vault workflow that avoids storing plaintext credentials.

A hook-based delegation system that routes Claude Code tasks to 8 specialized agents with support for both isolated subagent workflows and collaborative Agent Teams, using adaptive soft-enforcement nudges and intelligent dependency analysis for parallel or sequential execution. The system enforces structured task decomposition through plan mode, with lean SessionStart injection, task tracking via Tasks API, and real-time inter-agent communication for multi-step workflows.

This Claude Code plugin sends telemetry data from Claude Code sessions to PostHog LLM analytics via a session-end hook. It provides LLM usage tracking and session analytics without requiring external API keys.

metro-mcp is an MCP server for debugging and automating React Native/Expo apps via Metro's Chrome DevTools Protocol, offering tools for console logging, network inspection, component tree analysis, UI automation, and test recording without requiring app code changes. It supports iOS Simulator and Android devices, provides a CDP proxy for simultaneous Chrome DevTools access, and includes plugins for Redux inspection, React Navigation state, performance profiling, and deep link testing.

A library of four agent skills for managing SAP AI Core resources, deployment lifecycles, foundation models, and tabular data orchestration. The skills enable agent-driven administration and model discovery/deployment through natural language commands.

Claude Praetorian automatically preserves conversation context by prompting to save and restore valuable context at strategic moments—before planning, after research, and when subagents complete. It integrates with an MCP server to manage context compaction and restoration across Claude Code sessions, reducing token usage by 50–60%.

Claude Vigil creates file checkpoints before destructive bash operations (rm, mv, git reset) and provides tools to diff changes and restore files safely using content-addressable storage. Commands and MCP tools let users manually save named snapshots and restore from them on demand.

MLflow Skills equips coding agents with observability, debugging, and evaluation capabilities for GenAI applications through tracing, trace analysis, and quality measurement. The plugin includes an optional UserPromptSubmit hook that auto-suggests relevant skills when MLflow-related patterns are detected in prompts.

This standalone Agent Skill provides local CLI and tailnet-wide API operations for Tailscale mesh VPN management, including status checks, device authorization, file transfer, SSH connectivity, DNS configuration, and ACL policy validation. It requires optional Tailscale API key configuration for tailnet-wide operations but supports zero-config local CLI usage.

This skill provides comprehensive ZFS pool management for homelab environments, including health monitoring, snapshot automation via Sanoid, and pull-based replication across 5 devices using Syncoid. It handles pool properties, performance optimization, scrub scheduling, and troubleshooting workflows without requiring external APIs or paid services.

A toolkit that scaffolds and retrofits AI-agent-friendly projects with enforcement hooks, config templates, and engineering patterns, including a self-improvement loop that learns from project usage to propose better rules over time. The plugin installs 8 skills for project setup and management plus 9 hooks for safety enforcement and signal capture.

HCF orchestrates autonomous parallel development by separating interactive planning from fully autonomous TDD execution, using a 3-agent architecture with 4 skills to implement features with test-driven development and dependency resolution. The plugin coordinates multi-worker batches across hook points (pre-plan, post-plan, pre/post-implementation, pre/post-batch, pre/post-commit) and maintains all state in plan files for resumable, context-aware runs.

Optimus sets up your Claude Code project with AI-optimized CLAUDE.md files, coding guidelines, formatter hooks, and built-in quality agents (code review, refactoring, TDD, test coverage) learned from your actual codebase. It runs 19 skills that establish project context and enforce code quality standards across Red-Green-Refactor cycles, deep-fix loops, and resumable testing workflows.

This Claude Code plugin enforces git safety rules (blocks force-push and direct pushes to protected branches) and provides autonomous skills for debugging and merge-conflict resolution. It injects prose-rule templates into projects and runs optional bash-level guards at strict enforcement profiles.

An always-on Claude Code agent that runs locally on your machine or server, accessible from the terminal, Claude app, Discord, Telegram, or custom channels. It maintains ongoing responsibilities like system monitoring and research routines, carries progress across sessions, and proactively surfaces work that needs attention.

claude-code-hermit is a personal always-on AI assistant that lives in your project with memory-driven learning, autonomous task execution, and self-improvement through experience reflection. It runs 24/7 via Docker or tmux, handles crash recovery, executes background routines, and learns from patterns to propose operational improvements.

Turns Claude Code into a 24/7 home automation agent for Home Assistant, providing read-first monitoring, safety-gated automation drafting and structural management, and daily/weekly health routines. Integrates with the official Home Assistant MCP Server and REST API, gating every actuation with a fail-closed safety hook and requiring explicit approval before applying changes.

A Claude Code plugin that enforces git safety and dev discipline for unattended agents through configurable hooks, prose rules, and hard bash-time blocking of force-push, --no-verify, and direct pushes to protected branches. It includes autonomous skills for debugging workflows and resolving merge conflicts, plus an instruction template (CLAUDE-APPEND.md) that applies consistent rules across all code-writing agents in a project.

This plugin transforms Claude Code into a 24/7 Home Assistant management agent that learns your house layout, monitors device health, and drafts automations while blocking unsafe actions by default. It integrates with Home Assistant's official MCP Server and REST API, running routines for pattern detection, security audits, and integration monitoring—all changes require your approval before execution.

Fable Orchestrator routes multi-agent work across Claude Fable 5 (planning), Sonnet 5 (volume), and Opus 5.5 (hard tasks) to minimize Fable token consumption, with automated spawn management and a strict output cap. The plugin uses hooks to delegate by default, enforce per-worker visibility in tmux, and deny unnamed spawns while allowing the chair to remain focused on planning and arbitration.

devpace is an AI-native development harness for Claude Code that enforces goal-to-code traceability, automated quality gates, impact analysis for requirement changes, and cross-session continuity through multi-role collaboration and comprehensive hooks. It manages the full development lifecycle from business goals through requirements to code changes, with automatic context restoration between sessions and human-approval-required quality gates that cannot be bypassed.

This Claude Code plugin provides 24 skills to configure RevenueCat projects, manage in-app purchases, and access revenue analytics through an MCP server connection authenticated via OAuth. It enables setting up apps, products, entitlements, and offerings, while also allowing users to monitor project status, manage store products, and review monetization data—all from within the Claude Code environment.

Tonone is an open-source Claude Code plugin that bundles 100 AI specialists across engineering, product, operations, legal, design, data science, security, developer experience, infrastructure, and AI operations — each with deep domain expertise in their field. Users invoke specialists via commands like /apex-plan or /forge-infra to get production-ready work across the full software development lifecycle without external paid services.

guardrails is a PreToolUse hook that prevents destructive Bash commands during Claude Code execution by hard-blocking catastrophic operations like rm -rf / and docker volume rm, while allowing safe deletions within the workspace scope after confirming ambiguous cases. It inspects normalized command syntax with heredocs and comments stripped, making it effective against accidental or malicious filesystem damage without impeding legitimate development work.

A Claude Code plugin bundling seven skills that teach AI agents how to build, test, debug, and deploy voice agents using the LiveKit Agents SDK for Python and Node.js, integrated with the LiveKit Docs MCP server for live API lookups and SDK code search. The skills cover the full development loop—architecture, debugging via live conversation, turn-level testing, scenario simulation, deployment to LiveKit Cloud, and production operations—so agents work from current documentation instead of stale training data.

This Claude Code plugin sets up an experimental local subscription gateway proxy that intercepts and manages Claude API traffic through setup and disable commands. It operates independently of tracing and hooks into session lifecycle events and user prompts to monitor subscription usage.

This Claude Code plugin traces conversations, tool calls, subagent executions, and context compaction events to LangSmith for observability and debugging. It integrates via 7 hooks into Claude Code's execution lifecycle and requires Node.js v18+ to run.

This Claude Code plugin provides a comprehensive toolkit for creating, validating, and distributing Claude Code plugins, featuring slash commands for scaffolding, a reviewer agent for audits, and ambient guidance via a skill component. It includes 7 commands, 1 agent, 1 skill, and 3 automation hooks (PreToolUse, PostToolUse, SessionStart) to enforce validation guardrails throughout the plugin development workflow.

peepshow converts videos, animated GIFs, APNGs, and WebPs into extracted frame sequences, audio tracks, and transcripts that Claude can analyze as images and audio. It integrates with Claude Code via drop-and-drop support and provides pluggable sink backends to route extracted content to 95+ downstream systems including storage, databases, chat platforms, and analytics services.

archcore is a Claude Code plugin that enforces your project's architecture, rules, and decisions during AI-assisted coding by injecting context through session hooks and tool-use events. It uses 4 commands, 2 agents, and 4 skills to guide code generation while maintaining compliance with your project's architectural standards.

Claude Code on Steroids extends Claude Code with 24 production-grade skills across discipline, domain expertise, intelligence, coordination, and execution layers—built on obra/superpowers with 10 new skills, token burn optimization, and update-proof overrides. The plugin includes pre-verification for APIs, multi-agent templates, skill chain recipes, domain trigger mappings, and a /tokenburn CLI for cost analytics, reducing typical debugging token spend by 60–99%.

claude-leverage is an AI-coding-agent suite for Claude Code and Codex CLI that enforces security hooks, self-maintaining conventions, and cross-tool skills to keep repositories safe for sustained agent-driven development. It provides 16 skills, 3 subagents, and 9 deterministic security hooks that automate repo maintenance, surface context at edit time, and block dangerous operations before they happen.

Toonify MCP automatically compresses large tool output—JSON, YAML, stack traces, and logs—before it enters Claude Code's context window, reducing token usage without breaking workflows. It runs as a zero-config Claude Code plugin or optionally as an MCP server or pipe filter for any agent CLI.

This Claude Code plugin provides optional game development safety hooks that detect popular game engines (Godot, Unity, Unreal, web frameworks) and remind you of the project type, require confirmation before touching secrets/signing keys/destructive Git commands, and notify when written files are empty or when tests should be run. It operates through three shell scripts triggered on session start, before tool use, and after write operations.

SuperClaude for SAP (sc4sap) is a Claude Code plugin providing 28 specialized agents and 17 workflow skills for end-to-end SAP ABAP development, connecting directly to SAP systems via MCP to create, analyze, and manage ABAP objects with multi-environment profiles and built-in security controls. It supports SAP ECC, S/4HANA On-Premise, and S/4HANA Cloud with Clean ABAP review, program generation with Phase 4/6 hardening, package-to-process business documentation, and 14-module consultation across retail, automotive, pharma, and other industries.

Shipyard is a Claude Code plugin that orchestrates the full software project lifecycle—from brainstorming and planning through parallel-agent building, code review, security audits, and shipping. It integrates spec-kit for spec-driven development, runs test-driven builds with quality gates, and provides state management via shell hooks.

A Claude Code plugin that routes Siemens TIA Portal engineering automation tasks to 19 specialized skills covering Python TIA Scripting V1.4.3, C# Openness API domains, Modular Application Creator workflows, and Add-In development. It includes MCP write-safety hooks, diagnostic tools, and integrates with TIA Portal V21 via an MCP server for direct interactive automation.

archcore enables spec-driven development for AI coding agents by using project context stored in Git to generate and enforce architectural specifications. The plugin provides commands, agents, and skills that hook into the tool-use lifecycle and session initialization to guide code generation toward architectural consistency.

This Agent Skill provides comprehensive reference documentation for Apple's xcrun developer tool ecosystem, covering xcodebuild, swift build, simulator management, device deployment, code signing, and binary inspection. A paired Subagent executes builds, tests, and deployments for Swift packages and Xcode projects while delegating complex command construction questions to the Skill.

This Agent Skill repository provides four release automation workflows for HyperWhisper, a cross-platform speech-to-text application: linux-release, macos-release, windows-release, and localisation-syncer. The skills orchestrate version bumping, release note generation from git history, GitHub Actions triggering, and verification of published binaries across all three platforms plus localization synchronization.

AgentLint evaluates repository harnesses (context files, CI config, instructions) used by AI coding agents, scoring them across six core dimensions with 58 deterministic checks. It offers both a CLI tool and Claude Code plugin with guided fixes and evidence-backed recommendations to improve agent reliability.

context-guru intercepts and optimizes Claude Code sessions through a local proxy, reporting token and latency savings achieved. It installs as a reversible proxy layer with hooks into session start and prompt submission, using shell scripts to manage the proxy lifecycle.

Forge is a native Claude Code plugin that automates spec-driven development through a five-phase autonomous loop: brainstorming acceptance criteria, planning task DAGs, executing tests-first in parallel git worktrees, reviewing and verifying code, and backpropagating spec gaps. State persists on disk in .forge/ to survive context resets and crashes, allowing a single one-line idea to produce reviewed, tested, and committed code without manual intervention.

Buildable is a local-first product-structure compiler and quality gate that transforms vague prompts into runnable Next.js or Expo prototypes by selecting archetypes, design systems, and build-verified starter templates. It includes 15 golden starters and 61 recognized archetypes with micro-blocks and UI/UX guidance, plus a review loop that validates build, layout, accessibility, and state coverage without requiring a hosted platform or API keys.

This plugin integrates the ase (Agentic Software Engineering) tool into Claude Code, enabling 10 agents and 54 skills for automated software engineering tasks. It provides hooks into the development lifecycle (pre-tool use, session management, user prompts) and includes shell execution capabilities.

The /deep-implement plugin orchestrates a disciplined implementation workflow that takes section files from /deep-plan and builds them with test-driven development, integrated code review, and structured git commits. It automates the execution cycle of writing tests first, implementing code, running code review, gathering user feedback, and committing changes atomically.

Harness Evolver autonomously improves LLM agent codebases by evolving prompts, routing, tools, and architecture using multi-agent proposers, LangSmith experiments, and git worktrees. Self-organizing agents iteratively propose, evaluate, and merge improvements while gatekeeping regressions and tracking evolution memory.

cc-suite is a Claude Code plugin that synchronizes instructions, skills, hooks, and MCP servers across Claude Code, Codex CLI, and Antigravity CLI, enabling bidirectional delegation between them and optional integration with Grok Build, Qwen Code, opencode, and Kimi CLI. It provides 45 commands and 13 skills to manage single-source AGENTS.md files, shared skill trees, mirrored hook events, and bounded code review through Qwen or delegation to Grok.

A production-ready prompt library of 35+ specialist prompts covering the APEI cycle, task-routing, and reference hooks for Claude Code agents, Skills, MCP, Plugins, and subagents. The plugin includes six operational skills (find-prompt, deterministic-checks, changelog-from-commits, doc-link-audit, skill-audit, capability-audit) and two deterministic safety hooks that block destructive commands and credential writes.

A 37-skill agent that operates the entire Oracle AI Data Platform (AIDP) Workbench in natural language, discovering catalogs into a grounding cache and turning English into accurate Spark SQL for the full lakehouse lifecycle (DDL/DML, pipelines, clusters, debugging). It extends data engineering with AI governance (roles, credentials, Delta Sharing, audit logs) and ships guarded AI through Agent Flows, Knowledge Base RAG, and LangGraph agents, plus signature differentiators like LLM-in-SQL via ai_generate() and cross-source federation.

An MCP server that enables AI coding agents to create, manage, and control the lifecycle of Quarkus applications through tools for project scaffolding, dev mode management, extension discovery, and documentation search. It runs as a persistent process that survives crashes, supporting project creation via Quarkus CLI, Maven, or JBang with optional Docker/Podman for documentation features.

Session Orchestrator manages structured development sessions with wave-based planning, VCS integration, inter-wave quality gates, and session persistence across Claude Code, Codex CLI, and Cursor IDE. It enforces design-code alignment, ecosystem health monitoring, and safety checks via hooks while collecting cross-session metrics for adaptive workflow optimization.

This plugin provides expert guidance on Git workflow best practices, including branching strategies (Git Flow, GitHub Flow, trunk-based), commit conventions, collaborative workflows, and CI/CD integration with built-in commit validation hooks. It includes a `/pr-finish` command that automates pull request merging by preflight checking, rebasing, fixing CI, and resolving review threads.

This Claude Code plugin installs three safety hooks for firmware development that prompt for confirmation before flash/erase operations and secret-file access, detect embedded projects at session start, and flag empty files after edits. It integrates with Claude's tool-use pipeline using bash scripts to filter operations without requiring external services.

This Claude Code plugin adds optional safety hooks for firmware development workflows, requiring confirmation before flash/erase operations and sensitive file access, while detecting embedded projects at session start and flagging empty files after edits. It intercepts tool use events via bash scripts that parse JSON input without requiring external services or API keys.

This Claude Code plugin provides MCP integration with the Zscaler Zero Trust Exchange platform, exposing 402 tools across ZPA, ZIA, ZDX, ZCC, EASM, and Z-Insights services for managing policies, troubleshooting connectivity, and investigating incidents. The server operates in read-only mode by default for security and requires explicit opt-in to enable write operations.

This plugin integrates Claude Code with macOS's native caffeinate command to prevent system sleep during coding sessions. It activates automatically when a session ends to ensure continuous workflow without interruptions.

claude-mods is a Claude Code plugin providing 108 skills, 3 agents, 7 commands, and 6 hooks for modern development workflows, with executable tooling for React, Rust, PostgreSQL, Cloudflare Workers, and Next.js backed by test suites and staleness verifiers. It implements the Agent Skills specification and Anthropic's patterns for long-running agents, installing as a standard plugin with no external API key dependencies.

ArmorClaude is a Claude Code plugin that enforces intent-based security by intercepting user prompts to capture a declared plan, then verifies every tool call against that plan before execution and logs all actions for audit compliance. It supports policy-based access control with data classification rules (PCI/PII), optional CSRG cryptographic proofs, and runs in a fail-closed mode where all tool calls are blocked if planning, identity, or token verification fails.

assets-pack is a cross-vendor IT asset lifecycle management workflow that tracks warranty status, flags end-of-life/end-of-support devices, and plans hardware refresh cycles by aggregating device data from connected RMM platforms (Datto, NinjaOne, N-central, Kaseya VSA, ConnectWise Automate, Atera, SuperOps, Syncro, Action1, ImmyBot) and documentation tools (IT Glue, Hudu). It delivers portfolio-wide or per-client visibility into warranty expiration, OS/firmware support timelines, and tiered refresh calendars without requiring all platforms to be connected.

Claude Code plugin for Auvik cloud-based network monitoring that enables MSP analysts to interrogate device inventories, triage alerts, audit configurations, and plan capacity directly in chat through Conduit integration. Provides commands for device inventory reports, alert prioritization, network topology audits, tenant dashboards, and interface utilization analysis.

backup-pack bundles job health monitoring, restore-test verification, retention/RPO compliance, and DR readiness checks across connected backup and BCDR tools (Datto BCDR, Datto SaaS Protection, Spanning, Unitrends) via the WYRE MCP Gateway. It provides three independent skills and agents that discover what's actually connected and distinguish missed backups from failures, rank restore evidence, and flag retention/RPO gaps against contracts.

Cross-vendor network and cloud infrastructure operations pack that monitors device health, detects capacity issues, and identifies cost anomalies across Auvik, Meraki, Domotz, Azure, and DigitalOcean connections. It normalizes findings across different vendor models and operates through the WYRE MCP Gateway (Conduit), discovering connected tools at runtime and reporting what can be verified.

Bundles judgment and workflow for on-call handoffs, blameless postmortems, and error-budget tracking across any combination of incident-management and observability tools connected through the WYRE MCP Gateway. Discovers and adapts to whatever incident-management (Rootly, PagerDuty, BetterStack), observability (Sentry, Datadog, Grafana), and platform/deploy tools (GitHub, Cloudflare, Vercel, Netlify, Supabase, Neon) are actually connected, never hardcoding vendor APIs.

This Claude Code plugin integrates with ImmyBot to enable desired-state Windows software deployment, maintenance sessions, and script execution for managed service providers. It provides commands and tools for managing tenant software inventory, computer deployments, PowerShell script execution, and reconciliation workflows through Microsoft Entra ID OAuth.

This plugin adds LINE messaging platform support to Claude Code through an MCP server, enabling Claude to receive and respond to LINE messages in DMs and group chats. It requires Bun runtime and a publicly accessible HTTPS webhook endpoint, with configurable access controls via allowlists.

The ncentral plugin enables MSP technicians to manage N-able N-central RMM infrastructure directly from Claude, providing device inventory, issue triage, task status, and organizational property management across customer endpoints. All API calls route through Conduit, eliminating the need for local credentials or SDKs.

The ops-pack provides cross-vendor service-desk operations including board health auditing, dispatch prioritization, SLA monitoring, and shift handoffs by dynamically connecting to any PSA (Autotask, HaloPSA, ConnectWise, Syncro, Kaseya BMS) and optionally RMM or on-call tools through the WYRE Conduit MCP gateway. It bundles judgment logic for escalation decisions, dispatch scoring, and ticket hygiene on top of the connected PSA's native data without hardcoding vendor-specific APIs.

This Claude Code plugin integrates with ThreatLocker's zero-trust endpoint protection platform, enabling MSP analysts to triage application approval requests, investigate audit logs, and report on managed computer fleets without leaving chat. It provides commands for approval request prioritization, audit timeline assembly, computer inventory generation, offline agent detection, and multi-tenant pivoting across child organizations.

wigtn-plugins is an AI-native development plugin with 11 agents, 6 commands, and 7 skills for rapid end-to-end design-to-deployment workflows. It includes team-based parallel build capabilities, screen specification generation (IA/User Flow/Wireframe HTML), and WIGTN-brand PowerPoint generation across 20 design styles.

FiftyOne Skills enable Claude to build high-quality computer vision datasets and models through natural language commands like finding duplicates, running inference, and visualizing embeddings using the FiftyOne MCP Server. The plugin includes 18 skills for dataset import/export, model evaluation, curation, and custom plugin development, plus specialized skills for code style, notebooks, and troubleshooting.

This plugin packages a Cloud SQL for PostgreSQL MCP server to manage databases, execute queries, explore schemas, and troubleshoot issues using natural language prompts within AI agents like Claude Code, Antigravity, and Codex. It requires Node.js, Google Cloud authentication, and appropriate IAM permissions to connect to and interact with Cloud SQL instances.

A Claude Code skill package that enables AI-driven terminal multiplexer (cmux) operations, including pane splitting, command sending, screen reading, and sub-agent spawning with real-time monitoring and intervention capabilities. By running sub-agents inside cmux panes, you gain full visibility into their I/O and can inspect or intervene mid-task, unlike the opaque built-in Agent tool.

Strix Claude Code is an AI-powered penetration testing skill that runs security assessments using the Claude CLI with a Docker sandbox containing Kali Linux tools, MCP server, and browser automation. Users can launch scans via a TUI dashboard or CLI commands against web applications, APIs, domains, IPs, or source code repositories with customizable scan modes (quick, standard, deep).

A comprehensive skill library for Claude Code that provides 15 focused reference guides covering Netlify platform primitives including serverless functions, edge compute, databases, image CDN, forms, authentication, and deployment. The plugin connects to the Netlify MCP server to enable agents to build correctly on the Netlify platform without needing external documentation.

Railguard is a secure runtime for Claude Code that intercepts every tool call with policy-based allow/block/ask decisions, evasion detection via OS-level sandboxing, and memory safety features. It provides fine-grained access control between the all-or-nothing choice of manual approval or unrestricted execution, with path fencing, file snapshots, audit logging, and session replay capabilities.

Signet automatically signs every Claude Code tool call with Ed25519 cryptographic receipts and maintains a hash-chained audit log for compliance and verification. The plugin requires no configuration, stores keys locally, and uses a WASM module to sign tool actions without external dependencies.

Worktree Task launches autonomous Claude Code or Codex instances in separate git worktrees with automatic error recovery and monitoring. It handles background task execution, progress tracking, cleanup, and merge/rebase operations with macOS notifications.

fewword is a context engineering plugin that optimizes Claude's token usage through tiered offloading, smart summaries, and secret redaction with TOML/JSON configuration. It provides 21 commands, command aliases, MCP allowlists, and self-diagnostics to reduce context bloat and improve efficiency.

SentinelXPrime embeds stage-aware security guidance into AI coding workflows across planning, implementation, review, and pre-release checkpoints, surfacing security concerns at the right moment through stack-aware skills for multiple frameworks. It operates as advisory-first analysis with read-only, transparent output and no silent enforcement or false assurance.

This standalone Agent Skill repository provides 19 specialized skills for modernizing SAPUI5/OpenUI5 applications, including an end-to-end orchestrator that runs five validation phases to upgrade apps to manifest 2.0 with framework 1.136.0+. Skills target specific linter rule categories—from deprecated APIs and globals elimination to CSP compliance and test infrastructure updates—with git-backed phase commits and verification gates.

This skill converts JavaScript-based UI5 (SAPUI5/OpenUI5) projects to TypeScript, automating the migration of UI5 application codebases to a typed language. It works as a standalone agent skill that can be installed with `npx skills add` or integrated into Claude Code and GitHub Copilot coding agents.

This MCP server equips AI agents with Mobile Development Kit (MDK) expertise by providing access to MDK CLI tools, best practice guidelines, project templates, and metadata-driven development guidance. It enables AI-assisted development of cross-platform SAP mobile applications through comprehensive MDK knowledge integration.

This plugin provides 57 official Twilio skills and an MCP server (mcp.twilio.com) that enable AI coding agents to handle SMS, Voice, WhatsApp, Verify, and 30+ other Twilio products with guided product selection and compliance patterns. Skills use progressive disclosure to keep context lean while providing domain expertise for setup, planning, product implementation, and operational guardrails.

This plugin automatically loads credentials from a CLAUDE_ENV_FILE environment variable on session start and redacts secrets from CLI output in real-time using the nopeek CLI tool. It intercepts both session initialization and tool execution to prevent sensitive data from being exposed in logs or terminal output.

The OutSystems plugin connects Claude to your OutSystems Developer Cloud tenant via an MCP server, enabling you to edit apps, publish, deploy, search elements, and manage libraries directly from Claude Code. It uses OAuth to authenticate with your tenant and follows OutSystems conventions for destructive operations and long-running tasks.

Craftsman enforces software engineering discipline across Claude's development workflow through a rules engine, correction learning system, and real-time quality gates that apply identically in hooks and CI. It integrates domain-driven design, clean architecture, and test-driven development practices using multi-level rule inheritance, metrics tracking, and structural ratcheting to prevent architectural decay.

A Claude Code plugin that scaffolds CrowdStrike Falcon Foundry apps from natural language prompts, generating API integrations, workflows, UI pages, functions, and collections deployed to the Falcon console. It includes 12 skills with intelligent routing hooks that guide users toward Foundry-specific patterns and guard against common CLI mistakes.

dev-flow integrates code review, automated fixes, commits, and linting directly into Claude's development workflow through pre- and post-tool hooks that validate and process changes. It runs shell commands (bash, node, python3) at key lifecycle points to enforce coding standards and gate development actions.

This Claude Code plugin provides Git workflow utilities including worktree management, branch cleanup, secret scanning, and configuration validation. It implements guardrails via PreToolUse hooks that can allow, deny, or rewrite tool inputs based on custom policies.

Whetstone is an AI-powered development plugin with 18 agents, 22 commands, 32 skills, and 1 MCP server that automate code review, research, design, and workflow tasks across multiple programming stacks. It includes specialized agents for accessibility, security, performance, cloud architecture, database validation, Figma design sync, and deployment verification, with commands ranging from autonomous full-stack engineering (`/ia-lfg`) to targeted verification and documentation workflows.

super-token-saver automatically reduces Claude Code costs by 45% through smart session architecture, cache expiry prevention, zero-cost context restoration, and a real-time cost dashboard built from Claude Code source analysis. It delegates expensive operations to cheaper SubTasks, bundles tool calls to reduce round-trips, detects cache misses before they drain budgets, and provides live visibility into token spending.

This plugin provides 20 Agent Skills for building Wix app extensions, managing Wix business solutions, developing headless sites, and integrating the Wix Design System with AI agents via a Wix MCP server. It connects to the new Wix CLI and supports use cases ranging from dashboard pages and eCommerce to site migration from other platforms.

Consort is a spec-first, test-driven agent framework that orchestrates multiple AI roles through deterministic state machines to build transactional application backends on Lakebase (Databricks' serverless Postgres database), with every code change tested against a real, isolated database branch and human-approval gates that fail closed. It enforces engineering discipline through immutable test contracts and independent review, not suggestions, ensuring that "green" means a real test passed on a live database—not just an agent's claim.

The autopilot plugin automates the complete engineering workflow from requirements to code merge, with AI-adaptive speed modes, interactive brainstorming, red-team adversarial testing, and QA gating. It includes requirement management via project DAGs, intelligent commits, engineering health diagnostics, and automatic worktree initialization with knowledge base accumulation across tasks.

Brewtools is a Claude Code plugin providing text optimization/humanization, secrets scanning, SSH and GitHub Actions deployment, subagent governance guards (deadline/return-size/routing), task board, context measurement, and plugin management—all without external API keys. It includes 13 skills and 3 agents with hardened delegation controls via per-binary allowlists and approval gates for destructive operations.

A collection of three standalone Agent Skills for Django projects: fix-types (interactively fix Python type-checking issues), upgrade-js-deps (upgrade JavaScript dependencies with post-upgrade checks), and upgrade-python-deps (upgrade Python dependencies with post-upgrade checks). Installed via the Skills CLI and designed to work with AI agents like Claude Code to assist with Django development workflows.

Hardstop is a pre-execution safety layer that blocks dangerous shell commands and credential file reads using pattern matching against 428 security patterns plus LLM analysis for edge cases, operating on a fail-closed policy. It integrates as a hook into Claude Code to validate every command chain before execution and provides status, logging, and bypass controls.

Task Notifier is a Claude Code plugin that triggers system notifications and sound alerts when task-related tools complete execution (Task, TodoWrite, TaskComplete, TaskUpdate). It supports macOS, Linux, and Windows with a 10-second timeout mechanism and zero-configuration cross-platform notification using native system APIs.

Claude Architect is a Claude Code plugin that delegates coding tasks to isolated producer agents (Codex, OpenCode, Pi, Pythinker, Antigravity CLI, or headless Claude) in detached Git worktrees, then independently verifies and reviews their work before human-controlled integration. It enforces isolation, evidence-based verification, and separated authority—the host Claude reviews and decides on frozen candidate artifacts without the producer being able to approve its own changes.

Official Google Cloud Storage plugin that bundles 5 Agent Skills with a Cloud Storage MCP server for managing buckets, objects, data transfer, security, and infrastructure. The skills provide natural-language expertise for access diagnostics, security assessments, FUSE mounts, and bucket architecture while the MCP server offers structured tools via MCP Toolbox.

This plugin integrates Google Cloud Firestore databases with Claude Code and other AI agents via the MCP Toolbox server, enabling natural language queries to manage databases, collections, and documents. It supports exploration of schemas, data retrieval, and code generation for data classes based on document structures.

TwinCAT-Agent automates PLC development for Beckhoff IEC 61131-3 using a dedicated agent with strict Structured Text rules, naming conventions, and syntax validation. It integrates local TwinCAT XAE automation and remote Beckhoff InfoSys documentation lookup via two MCP servers.

A comprehensive suite of 16 specialized AI agents and 10+ enterprise commands that extends Claude Code for security audits, DevOps automation, performance testing, and code review across multiple languages. No external API keys are required as all functionality is self-contained within the plugin.

This Claude Code plugin scaffolds Mercado Pago payment integrations (Checkout Pro, Checkout API, Bricks, QR, Point, Subscriptions, Marketplace, Wallet Connect, Payouts, SmartApps) via an orchestrator agent with four specialized skills: mp-integrate (wizard), mp-webhooks (HMAC validation), mp-test-setup (test credentials), and mp-review (security audits). Scaffolding works offline using bundled contracts; live operations like credential import and webhook registration connect on demand via the official Mercado Pago MCP server without requiring upfront API key setup.

This PayPal plugin integrates PayPal's APIs and sandbox MCP server into Claude Code and OpenAI Codex, enabling AI-assisted development for payments, subscriptions, invoices, and disputes through commands, skills, and direct API operations. It includes best-practices guidance via auto-injected skills and pre-tool hooks, plus commands for setup, troubleshooting, and sandbox testing.

React Native HiFi provides a comprehensive agent workflow for React Native and Expo development, featuring 39 skills that guide agents through design refinement, TDD-driven implementation plans, subagent-driven development, and specialized patterns for native UI, testing, and debugging. It integrates production-grade techniques from Software Mansion and Callstack, emphasizing red/green TDD, code review workflows, and autonomous multi-agent collaboration for extended development sessions.

Agent Guard is a local-first guardrail that inspects user prompts, tool inputs/outputs, and changed files in Claude Code and Codex sessions to block or mask credential leaks before they occur. It uses hooks across session lifecycle events and includes optional PII filtering and Git/CI integration points for defense-in-depth secret leak prevention.

This Claude Code plugin monitors Claude updates by tracking changelog entries, detecting breaking changes, and analyzing community sentiment through Exa search integration. It provides plugin compatibility analysis and real-time notifications via post-tool-use hooks to keep developers informed of relevant updates.

Provides expert Go 1.26+ development guidance with 1 agent and 5 skills covering idioms, concurrency, testing, tooling, and backend services, all adhering to SOLID principles and golangci-lint v2 standards. Activates automatically in Go projects with a go.mod file and requires bun as an external tool.

This Claude Code plugin provides an expert Next.js 16 developer agent with 11 specialized skills covering App Router, Server Components, Prisma 7 ORM, Better Auth authentication, TanStack Form, Zustand state management, and shadcn/ui components. It automatically activates when working in Next.js projects and guides modular architecture using SOLID principles.

fuse-rust is an expert Rust 1.96+ (2024 edition) agent with 7 skills covering ownership, error handling, async/tokio, axum backends, testing, tooling, and ecosystem crate selection. The agent activates in projects with Cargo.toml and enforces clippy-clean, SOLID-principled code practices.

fuse-solid enforces SOLID principles across multi-language projects through automatic project detection and validation via an integrated agent. It integrates hooks into the development workflow to check code patterns before and after tool use, plus at session start.

This Claude Code plugin provides an expert TanStack Start full-stack developer agent with 9 specialized skills covering file-based routing, server functions via createServerFn, middleware, server routes, authentication, and Nitro deployment. The agent auto-activates when a TanStack Start project is detected (via @tanstack/react-start and tanstackStart() Vite plugin) and guides developers through framework fundamentals, selective SSR, and isomorphic execution patterns.

The fuse-typescript plugin is a Claude Code agent that provides expert guidance for pure TypeScript projects targeting TypeScript 6.0, Node 24 LTS, or Bun 1.3, with skills covering configuration, language patterns, runtime features, linting, testing, and packaging. It activates automatically for TypeScript projects without framework configs and enforces SOLID principles through strict typing, ESM-first packaging, and modular architecture.

This Claude Code plugin provides 11 skills, 2 agents, and 1 command for querying and analyzing Honeycomb observability data, including production investigations, SLO tracking, and OpenTelemetry instrumentation guidance. It integrates with the Honeycomb MCP server to enable workflow automation around pattern detection, incident analysis, and Beeline migration tasks.

Intercepts Claude Code's context compaction and replaces it with Morph Compact's service, achieving 25,000+ tok/s compression in under 2 seconds. The plugin hooks into the PreCompact, SessionStart, and UserPromptSubmit lifecycle events, storing the Morph API key locally and using prompt injection to minimize Claude's default summarization.

This plugin enables developers to build and deploy Prismatic custom components, Code Native Integrations, and embedded marketplace experiences directly from Claude. It provides commands, agents, and skills for managing the full development lifecycle of Prismatic integrations using Node.js and npm.

Ucai is a Claude Code plugin that implements an 8-phase build workflow with native architecture components: commands, agents, skills, and hooks for enforcing structured development with pre-flight audits, deterministic phase enforcement, and persistent task tracking. It replaces external frameworks by mapping directly to Claude Code's native systems and includes author/reviewer separation for tests, multi-agent code review, and autonomous spec-to-PR pipelines with zero approval gates.

APort Agent Guardrails intercepts tool calls before execution and evaluates them against a passport-based security policy, blocking unauthorized actions through a PreToolUse hook. It provides deterministic authorization enforcement across multiple frameworks (Claude Code, OpenClaw, LangChain, CrewAI, and others) using either hosted or local passport policies, with verified resistance to prompt-injection attacks.

NEXO Brain is a local cognitive runtime that gives Claude Code persistent memory, overnight learning, and self-healing background job execution through an MCP server and 8 lifecycle hooks. It tracks session state across multiple MCP clients, learns from corrections, and includes startup preflight diagnostics and optional dashboard integration.

Plugin providing 7 skills for authoring, deploying, and executing CrowdStrike Falcon Fusion workflows via YAML with live action discovery, schema validation, import, execution monitoring, and SIEM lookup file management. Requires CrowdStrike Falcon API credentials with Workflow scope and runs local shell scripts for integration.

This Claude Code plugin sends session transcripts to Langfuse, capturing user prompts, model generations with token/cost data, tool calls, thinking blocks, and images with no code changes required. It integrates via hooks into Claude Code sessions and supports tracing across agent turns, subagents, skills, and cache metrics.

This plugin provides 50 agent skills and an MCP server for LaunchDarkly feature flag management, including flag creation, targeting, cleanup, guarded rollouts, and metrics. It also includes AgentControl skills for managing LLM configs and experiments with built-in support for A/B testing and prompt management.

supertool batches multiple file operations (reads, greps, globs) and git/GitHub queries into single round-trips to reduce token consumption and API costs in Claude Code runs. It includes session-start injection and optional enforcement mode to block competing tools.

A collection of 15 Apple-authored Agent Skills bundled with Xcode 27, covering SwiftUI best practices, App Intents correctness, document-based apps, accessibility audits, testing modernization, and developer tooling. Install via `npx skills add` for use in Claude Code, Codex, Cursor, Cline, and ~70 other agents, with optional integration of Xcode's mcpbridge MCP server for device interaction and translation features.

Claudebase backs up and restores your entire Claude Code environment (agents, skills, hooks, rules, memory) to a private GitHub repository with multi-machine conflict detection and profile-based context switching. It provides secret scanning, automatic timestamped backups, and supports team-shared configurations with per-person overlays.

This Claude Code plugin connects to the Duck Duck Duck desktop app to score prompts and responses using on-device Apple Foundation Models, and deliver voice reactions to your coding sessions. It registers lifecycle hooks that post evaluation data to the widget's local server and handle voice-based permission gates, with all processing staying on-device for privacy.

A Claude Code plugin that bundles six Atlassian Forge-focused skills (app builder, review, cost optimizer, debugger, connector, and security audit) alongside two MCP servers providing live Forge documentation and Atlassian Design System lookup. The skills guide developers through scaffolding, deploying, debugging, and optimizing Forge apps on the Atlassian platform.

This Claude Code plugin provides an optional MCP connection to Neon for use within the JMO workflow, requiring your own Neon account and OAuth authentication. It integrates Neon's serverless PostgreSQL capabilities directly into the Claude Code environment.

This Claude Code plugin provides 21 commands, 29 agents, and 15 skills to streamline AI-assisted development workflows with session management and task verification. It integrates shell-based utilities for session multiplexing, todo persistence, and deliverable validation across tool use and session lifecycle events.

This Claude Code plugin wraps Google's MCP Toolbox AlloyDB server to let you create, connect to, and query AlloyDB for PostgreSQL instances using natural language prompts. It supports database lifecycle management, schema exploration, SQL execution, and code generation through an integrated MCP server.

A planning-first LLM OS for software engineering with hierarchical task planning (T0-T4) that persists across session resets, 25 agents across 5-phase TDD, forensic reasoning traces, and integrated MCP security gates. It features cross-tool portability (Copilot/Codex/Cursor compatibility), 60 skills, 24 commands, conflict detection, and self-healing safety mechanisms with durable project-context snapshots.

This plugin gives Claude Code a real browser (Chrome or Browser Use Cloud) via the Browser Use CLI, enabling web browsing, scraping, form-filling, and workflow automation. It registers the Browser Use MCP server with browser_exec and browser_screenshot commands, self-installing and staying current via uvx.

Crewforth provides disciplined agents and skills for Claude Code with tool-level gate hooks that enforce commit/push approval, guard destructive operations, and measure context usage. It includes git commit trace, secret, and bloat scanning through bash integration and session rehydration capabilities.

A multi-agent autonomous development framework that transforms tickets into pull requests, orchestrating specialized agents (Opus, Sonnet, Haiku) for triage, backend, frontend, database, DevOps, code review, QA, and security tasks in parallel. Installs as a CLI tool or Claude Code plugin and supports both interactive and autonomous modes, with optional VPS pipeline integration via the Just Ship Board.

This plugin assesses your current cloud infrastructure and billing on GCP or Heroku, then generates production-ready Terraform, migration scripts, and cost comparisons to recommend whether AWS migration makes sense. It also detects AI/agentic workloads and recommends specific Bedrock migration paths with real-time pricing data and framework-specific gotchas.

SFAgent Tools is a Claude Code plugin that automatically generates and executes comprehensive test scenarios for Salesforce Agentforce agents, running headless conversations, validating behavior against business rules, and producing scored reports with improvement recommendations. It reads an agent's configuration, designs test cases for topics and edge cases (including guardrail testing), conducts real multi-turn conversations, and delivers structured evaluation results without manual YAML setup.

claude-context-monitor watches your Claude Code context window in real time, predicts when you'll hit capacity limits, and recommends optimal `/compact` timing based on semantic topic drift analysis. It injects smart carry-forward instructions into compact operations to prevent cumulative amnesia across multiple context compressions.

gh-dash displays GitHub PR status, CI/CD checks, and merge capability directly in Claude Code's terminal interface, with live 10-second refreshes and auto-trigger hooks. Users can merge PRs in multiple strategies (squash, merge, rebase) and view bot comments from CodeRabbit, Cursor Bugbot, and coverage tools.

The Opik plugin automatically traces Claude Code sessions and nested agent calls to Opik, an open-source LLM observability platform by Comet, capturing tool use, thoughts, and responses as spans. It provides built-in skills for instrumentation, diagnosis, testing, evaluation, and optimization of AI applications, with support for frameworks like OpenAI, Anthropic, LangChain, and CrewAI.

Media OS is a comprehensive Claude Code plugin routing natural-language media production requests to 96 specialized skills across FFmpeg transcoding, HDR mastering, live streaming, broadcast tools (NDI, DeckLink, Dolby Vision), AI media processing, and OBS automation. It combines strict OSI-open AI model licensing, deterministic routed dispatch, safety hooks, and CLI toolbelt integration to handle production-grade workflows from video encoding and color grading to lipsync and PTZ camera control.

RocketSmith is an end-to-end model-rocket toolchain that orchestrates OpenRocket (flight simulation), build123d (parametric CAD), and PrusaSlicer (FDM slicing) to let agents design, simulate, and build rockets. It closes the loop by feeding real printed-part weights back into the simulation for post-build stability verification.

Arcane MCP Server provides 180 tools for managing Docker infrastructure through the Arcane Docker Management platform, including container, image, stack, and security operations via natural language commands. It includes safety guardrails, tool filtering to manage context window usage, and a companion skill with deployment workflows and troubleshooting patterns.

This Claude Code hook parses compound Bash commands (pipes, chains, subshells) into segments using shfmt AST and matches each against allow/deny lists to auto-approve when all parts are permitted. **This plugin is deprecated and archived as of July 2026; Claude Code now handles compound commands natively, and an unpatched security vulnerability exists where redirects bypass permission checks.**

The akf plugin auto-stamps Claude Code's file output with trust metadata, while checking that metadata before building on existing work. It uses PostToolUse hooks and an external autostamp.sh tool to track and verify provenance of AI-generated files.

This Claude Code plugin provides three skills for ROS 2 Jazzy development on Ubuntu 24.04: package creation/testing with verified builds, live runtime diagnostics for publisher/callback/TF issues, and micro-ROS guidance. It runs executable workflows and checks directly in the development environment with no external API dependencies.

This plugin provides personalized AWS guidance for startups, drawing on patterns from 350,000+ startups to advise on architecture, cost, security, and migration across multi-account and multi-region environments. It includes startup eligibility checks for AWS Activate credits and access to 60+ exclusive startup offers, built by AWS Startup Solutions Architects.

Connects AI agents to the hosted Grafana Cloud MCP server for AI-assisted observability workflows using OAuth 2.1 authorization with no local installation required. Provides 60+ tools for querying dashboards, datasources, Prometheus, Loki, Tempo, Pyroscope, and other observability backends, plus alerting, incident management, and rendering capabilities.

Grafana MCP server plugin that adds 40+ observability tools for AI-assisted dashboard, datasource, alerting, incident, and OnCall management directly in Claude Code. Requires Docker, a live Grafana instance, and a service account token with Viewer (or Editor) permissions.

This plugin equips Claude Code agents with wallet functionality via the Phantom Connect SDK, enabling token swaps, transaction signing, and address management across Phantom's supported blockchains. It provides 8 skills for app scaffolding, transaction handling, and message signing, plus 2 MCP servers for real-time SDK documentation and wallet operations.

pty-mcp is an MCP server that provides interactive pseudo-terminal (PTY) sessions for AI agents, enabling local shell execution, SSH connections, serial port access, and persistent remote sessions. The plugin integrates via a SessionStart hook and includes one skill for managing terminal interactions.

This SigNoz plugin provides 13 skills for MCP setup, documentation access, querying, dashboard management, and alert configuration within Claude Code. It runs shell commands and hooks into session initialization and tool usage events to integrate SigNoz observability into your development workflow.

claude-tab-fix is a Claude Code hook that fixes indentation mismatches between Claude's generated Edit tool calls and tab-indented files, and warns Claude about tab ambiguity in Read output. It automatically detects and converts indentation styles before Edit operations, preventing silent match failures on Go, template, and other tab-indented codebases.

This plugin integrates Datadog directly into Claude Code, enabling natural language queries of logs, metrics, traces, dashboards, and monitors through a preconfigured MCP server. It supports both OAuth and API key authentication, with no credentials sent to the AI model provider.

This Git plugin enforces branching best practices by blocking direct commits to the default branch and resolving merge conflicts during rebase, merge, or cherry-pick operations. It automatically recovers SSH authentication failures by retrying git operations over HTTPS using cached credentials from GitHub or GitLab CLIs.

This plugin automates GitHub workflow and Actions monitoring, managing CI/CD pipelines, pull requests, and repository rulesets directly from Claude Code. It provides skills for watching PR builds, attaching media, reviewing diffs, managing notifications, and building stacked PRs, with agents that configure branch protection and analyze failing logs.

This GitLab plugin provides skills for working with merge requests, monitoring CI/CD pipelines with real-time log streaming, and accessing GitLab's REST and GraphQL APIs, plus hooks that convert GitLab URLs to API calls and catch common GitHub-to-GitLab migration mistakes. It includes a logs agent that extracts relevant error information from failing CI jobs and enforces GitLab-correct syntax patterns.

This Claude Code plugin provides macOS-specific automation through two skills: jxa for JavaScript for Automation language guidance, and jxa-run for app-scoped JXA execution with AST validation. It includes a sandbox hook that respects `claude:dangerouslyDisableSandbox` markers to disable command isolation when scripts need to invoke Apple Events or access plugin data directories.

The newline plugin ensures all edited files maintain POSIX-compliant trailing newlines by checking file state before edits and enforcing trailing newline presence after writes through pre- and post-tool hooks. It integrates with the Edit, MultiEdit, and Write tools to preserve proper text file formatting automatically.

Salesforce Claude Code (SCC) is a unified AI development system featuring 17 expert subagents, 57 domain knowledge skills, and 29 automated quality gates for Salesforce development across Apex, LWC, SOQL, Flow, Visualforce, Aura, DevOps, and Agentforce. It integrates with @salesforce/mcp to provide institutional knowledge, code governance, and automated enforcement through hooks that validate quality on every code change.

This Claude Code plugin enables programmatic creation and execution of macOS Shortcuts by generating XML plist files and wrapping the native `shortcuts` CLI. It provides skills for authoring shortcuts, discovering available actions, and managing shortcuts lifecycle from deployment to execution.

This plugin enables Terraform Cloud workspace and run management, including plan/apply log retrieval and registry lookups through an integrated MCP server. It requires a TFE_TOKEN for authentication and provides skills for interacting with Terraform Cloud workspaces and the Terraform Registry.

This Claude Code plugin provides production-quality bash scripting capabilities with shellcheck compliance, robust error handling, and terminal UI formatting via Charmbracelet gum; it includes an MCP server for context7 integration and a gum-beautify skill for TTY-safe interactive output.

This Claude Code plugin automatically backs up sessions to a local git repository before compaction and at session end, preserving conversation history, debugging context, and architectural decisions. It detects session deletions, provides timeline views of archived sessions, and enables full session restoration from git history.

This Claude Code plugin reads infrastructure-as-code files (Terraform, CloudFormation, Kubernetes, Docker, and others) to automatically generate architecture and infrastructure diagrams using D2, and keeps them synchronized with code changes via drift detection. The plugin produces multi-level diagrams (detailed and simplified) in light and dark SVG variants, with 950+ cloud and technology icons and animated traffic flow visualization.

The go-specialist plugin provides 11 skills and an MCP server for mastering Go 1.25+ development with modern patterns, advanced concurrency, performance optimization, and production-ready microservices. It integrates with Context7 to offer code generation, linting, testing frameworks, and DevOps tooling like Taskfiles and GoReleaser.

This plugin embeds HawkScan dynamic application security testing (DAST) into Claude's agentic workflow, automatically generating stackhawk.yml configs, running scans via CLI or Docker, and transforming security findings into prioritized remediation tasks. It integrates with StackHawk's platform to validate configurations, parse results, and trigger re-scans after fixes to confirm remediation.

StackHawk Agent Skills teach your AI coding agent to scan for security vulnerabilities, report security posture, integrate scanning into CI/CD pipelines, and seed test data—all without leaving the coding workflow. The skill set includes HawkScan for DAST scanning, StackHawk API for cross-app reporting, CI integration, and data seeding capabilities.

This Claude Code plugin provides comprehensive software engineering support including code review, debugging, documentation generation, and license compliance checking. It offers 18 specialized skills for tasks like PR analysis, architecture diagramming with d2, terminal demo creation with VHS, and linting/testing, enhanced by a Context7 MCP server connection.

Postman for Agents provides 13 skills to bootstrap Postman setups, mock APIs before implementation, run collection and governance checks, monitor live endpoints, deploy and debug Postman Flows, and publish generated API documentation directly from your coding agent. The plugin runs shell commands and includes an MCP server integration that connects to Postman's hosted infrastructure for tool calls.

rails-cto is an opinionated Claude Code plugin that provides 17 specialist skills for full-stack Ruby on Rails development, covering planning, code generation, testing, linting, security scanning, and git automation with strict quality gates. It enforces code standards using RuboCop, Reek, Flog, Flay, Brakeman, and bundler-audit, preventing deployment without passing tests, lint checks, and review requirements.

A comprehensive Claude Code plugin for Tray e-commerce API integration, providing 36 skills, 11 agents, and documentation for 150+ endpoints including OAuth flows, webhooks, and best practices. It accelerates development for partners and community members building applications on the Tray platform.

This AWS development toolkit plugin provides 35 skills, 11 sub-agents, and 3 MCP servers for designing, building, migrating, and reviewing AWS architectures against Well-Architected best practices. It covers AWS services across compute, storage, networking, databases, and observability, with specialized agents for migration, cost optimization, Bedrock, and AgentCore development.

This Claude Code plugin orchestrates an issue-to-PR workflow that fetches tickets from Jira, Linear, GitHub Issues, or Azure DevOps, optionally pulls linked Figma designs, implements the solution with mandatory plan approval, enforces >95% test coverage and security review, generates e2e tests, opens a PR, and moves the ticket to review. It is stack-agnostic and detects project conventions from CLAUDE.md and .claude/ configuration files rather than imposing frameworks or test setup.

Hebb is a Claude Code plugin that learns from shell command failures and machine-specific issues, then prevents those failures in future sessions by stopping known-bad commands before they run and offering corrections. It works entirely locally by default, tracks command history through hooks, and optionally syncs learning across machines and AI tools with a free key.

Longhand is a persistent local memory system for Claude Code that captures every tool call, file edit, and thinking block into a searchable SQLite database on your machine. It enables semantic recall across sessions in ~126ms with zero API calls, keeping your full coding history even after Claude Code's built-in session rotation.

Magician is a full-stack SDLC plugin that automatically inspects projects, detects technology stacks, and orchestrates parallel agents through a complete workflow from design to merged PR with self-learning capabilities. It enforces TDD discipline, manages git isolation, performs multi-agent code review, and accumulates intelligence across sessions by learning patterns from previous work.

Manifestack audits your project's tech stack against budget, users, data compliance, and team constraints, then flags requirement gaps, duplicate services, vendor limits, and bills—with fixes from live vendor pages. It works read-only with no API keys, monitoring every new dependency your coding agent adds through a hook.

This standalone Agent Skill suite provides three development-automation utilities: commit (to stage and push git changes), translate-prompt (to convert Korean .ko.md prompts to English), and translate-readme (to generate English README from Korean versions). It integrates with an MCP Mermaid server to support diagram-based workflows within Claude's autonomous capabilities.

Staff Engineer Mode routes engineering questions to one of 64 specialist agents covering architecture, reliability, security, delivery, data, and operations—analyzing failure modes and verification checks before shipping code or production changes. The plugin uses a router to classify the requested artifact, lifecycle phase, and risk, then loads the appropriate specialist to deliver concrete decisions, risks, checks, and next steps.

trigger-tree measures which documentation your Claude Code instance actually discovers and whether injected instructions influence behavior, running locally with zero telemetry or token cost. It provides a live dashboard with heat maps, health diagnostics, and a CI gate that fails PRs on documentation discoverability regressions.

tx is a Git transaction workflow plugin that opens a branch as an integrity boundary, drives changes through OpenSpec-backed planning and verification stages, and squash-merges only when everything is clean. It uses guard hooks to keep protected branches and sync integrity intact across transactions that may span multiple Claude Code sessions.

version-up-alert is a Claude Code plugin that runs on SessionStart to check the marketplace for newer releases of all installed claude-automata plugins and displays an interactive notice listing any updates available. The plugin is automatically installed as a dependency of each claudé-automata plugin and uses a shell hook to perform version comparisons across the marketplace.

This Wasp plugin enhances Claude Code and other coding agents with integrated documentation, best practices, and configuration tools for developing full-stack web apps using Wasp (React, Node.js, Prisma). It provides skills for framework setup, feature configuration, deployment guidance to Railway or Fly.io, and a development server integration via MCP.

This Claude Code plugin connects to the Kobiton mobile testing platform, enabling you to manage devices, upload apps, run automation sessions, and view test results directly from your AI coding assistant. It integrates with multiple AI assistants including Claude Code, GitHub Copilot CLI, Gemini CLI, Codex CLI, and Cursor, and provides skills for interactive device testing and automation test execution.

The Story Driven Development (SDD) plugin synchronizes documentation with code by tracking changes through git diffs and status markers, automatically keeping stories and implementation aligned. It provides commands and hooks to integrate story-driven workflows directly into Claude Code's development environment.

URC bridges Codex and Gemini CLIs to Claude's phone-based remote control, letting you command either AI agent from the Claude App via a lightweight, self-managing Haiku relay that runs through tmux. The plugin includes an 11-tool MCP server for cross-CLI coordination and supports both synchronous phone control and asynchronous $0 hook-based passthrough messaging.

The ar plugin provides autonomous execution, file policies, and safety guards for Claude Code and other AI coding assistants through task-lifecycle checks and command safety validation. It integrates natively across multiple harnesses (Claude Code, Codex, Qwen Code, OpenCode, Pi, and others) with hook-based event handling and shared command grammars.

Autonomous experiment loop that continuously optimizes any measurable target (test speed, bundle size, LLM training loss, etc.) by editing code, benchmarking, and keeping only improvements. Includes domain-agnostic optimization engine and specialized LLM training templates for NVIDIA GPUs, with state persistence in git and JSONL for context-resilient resumability.

claudelint is a comprehensive linter for Claude Code projects that validates CLAUDE.md files, skills, settings, hooks, MCP servers, and plugins through both CLI and interactive plugin skills. It checks schema compliance, file structure, circular references, and security issues, with support for auto-fixing and strict validation modes.

This MCP server plugin enables AI agents to connect to Google Cloud SQL for MySQL instances and execute queries, manage databases, and explore schemas using natural language. It packages the MCP Toolbox's prebuilt cloud-sql-mysql server for use with agents like Claude Code, Antigravity, and Codex.

Credo is a self-contained process layer and mentor framework for Claude Code that enforces a project-local workflow with per-session modes (active/passive/autonomous), work-item lifecycle management with a hard Definition of Done gate, budget-aware autonomy, visual UI verification, and safety rules that propagate into subagents. It provides 15 commands, 26 skills, and 19 hooks to manage session state, task progression, API budget limits, and delegated work safety through composable shell-based tooling.

dogma synchronizes Claude instructions from a centralized source repository with intelligent merging, and enforces security and consistency rules via 33 hooks that detect AI traces, enforce permissions, validate secrets, and block risky operations. Teams and enterprises can maintain a single source of truth for coding standards and AI guardrails across multiple projects, while individual developers can keep their rules in sync across repositories and machines.

The limit plugin provides live API usage tracking and status information in Claude Code's statusline, displaying colored progress bars for rate limits (5-hour, 7-day, Sonnet, Extra Credits), Git information, token metrics, and session details. It also tracks personal highscores per pricing plan and can inject context-fill and cost information to the agent for autonomous cost awareness.

This plugin connects Claude Code to Oracle Database instances via an MCP server, enabling natural language queries, schema exploration, and database management without leaving the agent environment. It wraps Google's MCP Toolbox oracledb server to provide seamless database interaction for tasks like executing queries, monitoring sessions, and generating code from schemas.

The control plane for game-dev agents across Unity, Godot, Unreal, and S&box — compiles, tests, reviews, and routes work through verified hooks and 28 lifecycle-aware skills. Structured state in .qq/ and shell-based execution close the loop between code generation and verified deployment, with Claude Code-first integration and MCP compatibility for other agents.

Signal delivers desktop notifications tracking Claude Code's real-time activity—tool usage, permissions, session status—across Linux and WSL2 with optional sound alerts and AI-generated summaries. The plugin integrates via lifecycle hooks to display contextual information including repository, working directory, and terminal session details while preventing notification spam through smart filtering and serialization.

skilltotal is a Claude Code plugin that intercepts package installations via a PreToolUse hook, scanning each package for malicious indicators and suspicious patterns before allowing installation. It automatically denies confirmed threats and prompts for approval on high-risk packages, look-alike names, or packages that failed security checks.

cmdlens is a Claude Code plugin that analyzes Bash commands before execution, displaying risk assessments and recovery information to help developers avoid destructive operations. It uses Python-based hooks triggered at session start and before each command to evaluate shell safety.

Humanize turns terse local workflow requests into checked, reviewed, and runnable MCP flow packages via the humanize-plugin-mcp MCP server. This plugin enables Claude Code to manage multi-step workflows with automatic validation, locking, and review before execution.

Squidbrake intercepts every Claude Code tool call (Bash, PowerShell, file operations, WebFetch, MCP tools) and evaluates it against customizable rules before execution. Destructive commands are blocked, risky operations require approval via dashboard/phone/Slack, and all activity is logged in a tamper-evident audit trail.

Converts Google Stitch designs into pixel-perfect Next.js components with exact CSS values, fonts, and images preserved through a 7-phase extraction pipeline. It auto-detects your Tailwind version, downloads assets, maps design tokens, and validates output against the original design screenshot.

tailtest automatically generates and runs test scenarios whenever Claude Code edits a file, using production-shaped rules (R1-R15) and your existing test runner—no setup or prompting needed. It surfaces test results back to Claude in the same turn via hook-based integration, with optional adversarial mode to hunt edge cases across Python, TypeScript, JavaScript, Go, Ruby, PHP, Java, Kotlin, C#, and Rust.

wmux-orchestrator decomposes complex development tasks into parallel Claude Code agents coordinated through dependency-aware execution waves, with optional visual terminal panes via wmux or fallback to native subagents. Each agent operates independently while an orchestrator monitors progress, enforces task dependencies, and triggers automated review once all work completes.

Endor Labs workflow agents and setup for Claude Code that provides 11 agents and 1 skill for scanning and remediating code dependencies across multiple IDE and CLI platforms. The plugin runs shell commands and hooks into Claude Code's tool use workflow to enable automated security and configuration workflows.

The Appwrite Claude Code plugin provides language-specific SDK skills for TypeScript, Python, Go, Rust, PHP, Dart, Kotlin, Swift, Ruby, .NET, and CLI, enabling authentication, database queries, storage, realtime updates, and serverless functions. It includes a hosted MCP server at mcp.appwrite.io for workspace and project management with browser-based OAuth authentication, plus manual deployment commands for sites and functions.

CI-optimized code review plugin that runs 11 specialized review agents in parallel with confidence scoring and posts atomic GitHub PR reviews via the gh API. Supports multiple review profiles (single, lean, full, agent) with configurable severity filtering and focus areas.

Claude Tools provides guard hooks (command-guard, leak-guard, mcp-guard, post-guard) that enforce security policies on tool calls, credential access, and MCP server interactions through shell-based preflight checks. The guards require bun and fail safely open if bun is missing; users can opt into a hardened ISOLATED profile with credential restrictions and permission allowlists.

This plugin packages Google's MCP Toolbox cloud-sql-mssql server to enable Claude Code and other AI agents to interact with Cloud SQL for SQL Server instances. Users can execute queries, explore schemas, manage databases, and troubleshoot issues using natural language prompts.

This Control Plane plugin provides 30 skills and 2 agents for managing hybrid multi-cloud deployments across AWS, GCP, Azure, and private clouds, including workload deployment, secret access configuration, networking, and Kubernetes migration tasks. It connects to the Control Plane platform via MCP and executes operations through bash commands integrated with Claude's interface.

This Agent Skill provides comprehensive assistance with the Doppler CLI for secrets management, including project/config management, secrets injection, CI/CD integrations, and security best practices. Users can invoke it with `/doppler` or ask about topics like setting up Doppler, injecting secrets, syncing to cloud providers, and managing service tokens.

Meticulous agent skills enable Claude Code and other AI assistants to review visual regression test runs, investigate replays, debug diffs, and run tests on the Meticulous automated testing platform. The plugin includes seven domain-specific skills covering test review, test execution, iterative development, session simulation, and CLI utilities, with automatic connection to the hosted Meticulous MCP server.

Oasis Network development assistant that provides guidance on building dApps on Sapphire confidential EVM, creating ROFL off-chain applications, and working with the Oasis CLI and SDKs across Rust, Go, TypeScript, and Python. The skill activates automatically when Oasis-related development topics are mentioned, offering pattern examples and reference documentation for confidential contract deployment and off-chain app development.

This standalone Agent Skill provides plugin development tools for the cc-skills marketplace, including validation of SKILL.md frontmatter and auditing of hook scripts for silent failures. The skill contains 2 commands and 2 skills for scaffolding plugins, validating configurations, and detecting unhandled errors in shell and Python scripts.

This plugin bundles the Val Town MCP server with 11 platform skills for building and deploying applications on Val Town, including HTTP endpoints, cron/interval tasks, SQLite databases, email, OAuth, and React UI components. It enables developers to create serverless functions, scheduled jobs, and full-stack applications directly from Claude.

AI Maestro is a Claude Code plugin providing 8 skills for plugin development and orchestration, with lifecycle management through notification, session start, and stop hooks. It runs shell commands via Node.js and appears designed to manage multi-source plugin workflows.

CCF is a Claude Code plugin that enforces a context-first, spec-driven development workflow by keeping CLAUDE.md/.claude specifications continuously synchronized with code and grounding design decisions in best practices from Context7 and Microsoft Learn. It provides five slash commands, four analysis/research subagents, shell-based hooks for workflow enforcement, and integration with external knowledge bases—all operating within a single main session to avoid spawning costly separate contexts.

CodeLedger tracks token-level costs across Claude Code, Codex CLI, Cline, and Gemini CLI, breaking down spending by project, agent, and skill while separating user coding work from plugin overhead. It provides conversational MCP tools for querying usage, a local dashboard, budget alerts, and cost optimization recommendations based on evidence-based rules.

This Claude Code plugin integrates Confidence (Spotify's feature flagging and experimentation platform) directly into your editor, exposing 17 commands and 14 skills for managing feature flags, running experiments, and migrating from competing platforms without leaving your coding environment. It connects via 2 MCP servers to provide flag management, documentation search, guided onboarding, and one-command migrations from PostHog, Eppo, Statsig, or Optimizely.

excalidrawer is a code-first diagram generation tool that turns structured specs or agent intent into hand-drawn-style Excalidraw diagrams (flowchart, timeline, architecture, sequence) and exports them to .excalidraw, SVG, or PNG—no browser needed. The Claude Code plugin auto-registers an MCP server with five built-in skills and works entirely via CLI, programmatic API, or in-context agent commands.

kenji is a collection of 159 agent skills, 63 slash commands, and 6 subagents that automate multi-step engineering workflows—grill → build → audit → ship—for Claude Code, Cursor, Codex CLI, and Gemini CLI. It uses Firecrawl, Supabase, and Context7 APIs to handle feature specs, security audits, testing, deployment observation, and GTM workflows across React/Next.js stacks and other codebases.

This plugin connects Claude to ManageLM for remote infrastructure management, enabling natural language control over Linux and Windows servers across single or multiple machines. It provides 31 built-in skills for package management, services, networking, security audits, Docker, Kubernetes, databases, and file transfers through a secure outbound-only agent architecture.

masterplan orchestrates multi-hour engineering work through a durable brainstorm → plan → execute → finish lifecycle, storing all state on disk in run bundles to survive session crashes and compaction. It delegates work to short-lived subagents that return structured digests, keeping the chat session context lightweight while maintaining full resumability.

oddyssey is a CLI toolbox that integrates with OpenTelemetry and Grafana backends to enable Observability-Driven Development, allowing coding agents to observe local and remote application runs and feed insights into spec-driven improvement loops. The plugin provides 4 agents, 9 skills, 7 commands, and 4 hooks to coordinate observability data collection and analysis within the development workflow.

A hook-based extension that logs all Claude Code sessions in real-time to persistent files, automatically naming sessions from working directories and organizing tool calls, transcripts, and agent activity into configurable log channels. It provides `/renameAI` and `/sessioninfo` commands to manage and inspect session metadata, thinking traces, and failed tool calls across multiple runs and subagents.

sitemd is an MCP server plugin that turns markdown files into production-ready static websites with built-in navigation, search, themes, forms, analytics, and SEO — all configured through a local binary and settings files. It provides Claude Code with MCP tools for page management, content generation, site status, settings, and deployment to Cloudflare or any static host.

Wicked Garden is an AI-Native SDLC plugin that orchestrates end-to-end feature development through 81 specialist agents, enforced workflow phases, and quality gates that prevent incomplete work. It maintains cross-session memory with 3-tier persistence, enriches every prompt with project context via code search and structural intelligence, and runs entirely offline with local SQLite storage—no external API dependencies.