Browse plugins

Superpowers is a complete software development methodology library of 15 composable skills that guides coding agents through structured workflows: requirements gathering, design review, TDD-driven implementation planning, and subagent-driven autonomous task execution with continuous inspection and review. It activates automatically on session start across multiple coding agent harnesses (Claude Code, Cursor, Devin, Gemini CLI, GitHub Copilot CLI, Grok Build CLI, and others) without requiring explicit invocation or API keys.

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.

Hookify creates custom hooks to prevent unwanted behaviors by analyzing conversation patterns or explicit instructions, using simple markdown configuration files with regex pattern matching. It supports four hook events (PreToolUse, PostToolUse, UserPromptSubmit, Stop) and provides commands to generate rules, list configurations, and interactively manage hook behavior without requiring restarts.

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.

Claude-Mem for Cowork captures tool use via hooks and streams fragments to cmem.ai, where a Pro server runs the observer and compiles observations that are injected back into new sessions and spawned agents. Retrieval works via the existing MCP memory_search endpoint; capture is inert until cmem.ai's ingest/context endpoints ship.

The understand-anything plugin leverages AI agents to analyze, visualize, and explain codebases by orchestrating multiple skills that examine project structure, dependencies, and code semantics. It integrates grep and Node.js tools to extract codebase information and triggers understanding workflows at session start and after tool use.

Impeccable is a frontend design fluency plugin that provides 24 commands for design review, audit, and critique, with built-in anti-pattern detection to catch common frontend issues. It hooks into Claude Code's tool workflow and session events to automatically apply design checks as part of development.

ruflo-core is a foundation Claude Code plugin that registers the ruflo MCP server (314 tools) providing memory, embeddings, hooks, neural networks, autopilot, browser automation, agent orchestration, and system access, plus 4 generalist agents and 5 helper skills for plugin discovery and project initialization. It implements cross-cutting contracts for session management, 3-tier model routing, and a curated catalog of 32 sibling plugins with 7 architecture decision records.

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 restructures Claude's code output to be ADHD-friendly by leading with actionable steps, numbering tasks, suppressing tangential information, and making progress visible. It applies 10 formatting rules via a skill hook that runs at session start to transform verbose explanations into concise, action-oriented guidance.

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.

A Claude Code plugin that runs vulnerability scanning entirely within your session using a team of 9 agents to map architecture, build threat models, hunt for vulnerabilities, and verify findings before reporting. Confirmed findings are transformed into targeted patch files that you review and apply at your discretion.

Hookify creates custom hooks to prevent unwanted behaviors by analyzing conversation patterns or applying explicit rules defined in simple markdown configuration files. It supports regex-based pattern matching across multiple event types (bash commands, file edits, user prompts) with configurable warn or block actions.

Codex is a Claude Code plugin that enables code review and task delegation through a set of commands, agents, and skills integrated into the Claude Code environment. It leverages local Node.js execution to support automated code analysis and workflow automation.

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.

A four-tier memory ladder for Claude Code that captures and promotes session insights through recurrence-earned promotion gates (L0→L1→L2→L3), with human-gated adoption, redaction safety, and contradiction detection. Ships hooks for SessionStart/SessionEnd/UserPromptSubmit, five stdlib Python scripts (memory_core, memory_extract, memory_promote, memory_inspect, validate_examples), a /cs:memory command, and a cs-memory-curator agent.

This plugin compacts a conversation into a structured handoff document for another agent, with configurable storage locations, secret redaction, and automatic loading on the next session. It enforces a mandatory five-section checklist, suggests relevant skills for follow-up work, and uses SessionStart/SessionEnd hooks to ensure context is preserved across agent handoffs.

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.

This Claude Code plugin hooks into PreToolUse events to detect and warn about 12 common security anti-patterns (command injection, XSS, SQL injection, unsafe deserialization, code injection, and GitHub Actions workflow injection) before code execution happens. It caches session state and auto-cleans stale files after 30 days, and can be disabled per-session via environment variable.

This Claude Code plugin automates the curation of auto-memory by analyzing patterns, promoting proven learnings to enforced rules in CLAUDE.md, and extracting recurring solutions into reusable skills. It provides five slash commands—/si:memory-review, /si:promote, /si:extract, /si:memory-status, and /si:remember—along with error-capture hooks to maintain a structured self-improvement loop.

This plugin runs an offline self-improvement cycle at session end, harvesting past Claude Code interactions to identify recurring tasks and replay them locally to refine the agent's consolidated CLAUDE.md memory and SKILL.md skill definitions behind a held-out validation gate. Changes are staged for human review and only go live when explicitly adopted via `/skillopt-sleep adopt`, with a mock backend enabled by default to avoid API costs.

A Claude Code plugin that maintains persistent project planning files (task_plan.md, findings.md, progress.md) on disk and injects them via lifecycle hooks to preserve planning context across context-window resets, crashes, and /clear commands. It includes 13 commands and 6 skills with automatic recovery from project files and optional catchup modes for aggregate session counts.

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.

Claude SEO is an open-source Claude Code plugin that runs 26 sub-skills and 19 specialist agents in parallel to analyze technical SEO, content quality, schema markup, local SEO, e-commerce, and international SEO with recommendations grounded in Google's primary-source guidance. It includes AI-search optimization, Core Web Vitals analysis, backlink evaluation, and produces falsifiable audit reports with prioritized action plans.

Watch converts video files or URLs into timestamped frames and transcripts for AI agents, extracting native captions when available and optionally using local WhisperX or Groq/OpenAI transcription. It runs as a Claude Code plugin or standalone Agent Skill across multiple platforms including Claude Desktop, VS Code, terminals, and compatible agent frameworks.

claude-obsidian is a local-first knowledge system that captures sources, creates linked Obsidian notes with provenance ledgers, and retrieves grounded answers from your vault without uploading files. It provides 15 skills for ingestion, querying, linting, and maintenance with explicit consent workflows and optional methodology modes.

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.

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.

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.

Ouroboros sits in front of Claude Code as a plugin that clarifies vague coding requests through an interview before generating specifications, blocking spec generation until ambiguity scores pass a threshold. It redacts verification commands and expected-output assertions from the contract given to the worker, asking instead for the outcome to enable self-improving, replayable AI coding workflows.

autoharness is a self-learning skill layer for Claude Code that automatically discovers, merges, and validates skills learned from real agent sessions rather than offline benchmarks. It maintains a clean skill library by pruning unused skills and updating actively-used ones, touching only the skills it generates itself.

Claude Octopus is a plugin that orchestrates research, code review, and quality gates across Claude and up to ten external AI providers (Codex, Gemini, Antigravity CLI, Copilot, Qwen, Ollama, Perplexity, OpenRouter, OpenCode, and Grok) with consensus voting to catch blind spots before shipping. It delivers a four-phase workflow (Discover → Define → Develop → Deliver) with 32 specialized personas, 51 commands, 63 skills, and multi-LLM council deliberation modes for escalated decisions.

Ars Contexta generates a personalized knowledge management system through conversational setup, creating markdown vaults with wiki links, processing pipelines, automation hooks, and domain-native documentation—all derived from how you describe your thinking and work. The plugin provides 10 skills for extracting insights, finding connections, and maintaining your vault, plus a 6-phase pipeline that mirrors Cornell note-taking with a meta-cognitive layer for continuous system evolution.

SocratiCode provides semantic code search, dependency graph analysis, and context artifact exploration to give AI assistants deep understanding of entire codebases with zero configuration and no external API keys required. It works as a Claude Code plugin, MCP server, or VS Code extension, automatically indexing code at scale and keeping the index updated through file watchers across sessions.

Claude Code Harness enforces a disciplined delivery loop—plan, work, review, release—with pre-execution safety gates that adjudicate every tool call before it runs. It provides 4 agents and 21 skills including core verbs (/harness-plan, /harness-work, /harness-review, /harness-sync, /harness-release) to keep specifications, test coverage, and review independent from implementation, with two safety layers: a non-overridable runtime floor and configurable guardrails (R01–R15).

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.

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.

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.

brand-forge generates on-brand logos, social templates, and marketing graphics as vector SVGs without requiring any API keys or external accounts. The plugin stores a visual brand profile (colors, typography, logo rules) and applies it consistently across all outputs, with optional AI raster imagery via Gemini or OpenAI.

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.

Claude Never Forgets maintains persistent memory across sessions by automatically saving user messages, responses, and corrections to a local project memory file, then reloading them at session start to preserve context, preferences, and decisions. The plugin consolidates memories when they exceed a threshold to keep only important information while removing noise.

Content Multiplier transforms a single source—post, transcript, or idea—into a week of on-brand content across multiple channels and languages using two subagents (strategist and brand guardian) to plan, draft, and enforce consistency. It runs entirely inside Claude Code with no external API keys or accounts required, offering slash commands for brand setup, single-source multiplication, multi-week campaign planning, localization, and QA review.

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.

A Claude Code plugin that automatically formats code using Prettier with support for JavaScript, TypeScript, JSON, CSS, Markdown, and other file types through hooks and manual commands. It provides automatic formatting on file edits, validation commands, configurable rules, and Agent Skills activated by keywords like "format my code" and "fix formatting".

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.

PM AI Partner provides 12 specialized agent skills covering modes like Thought Partner and Technical Analyst, along with 6 workflow commands for planning, brief-writing, meeting prep, and competitive analysis. Three automation hooks integrate quality gates, draft tracking, and commit reminders into the PM's development workflow.

ServiceGraph is a metrics-enriched business dataset API that ships 18 agent skills to search and filter agencies, directories, newsletters, and product-launch platforms with a unified DSL and credit-based access model. The plugin includes a branded entry point that works against any dataset plus 14 specialized skills for US professional services (law, marketing, design, consulting, accounting, IT, engineering, HR, PR, cybersecurity, and more) and 3 product-directory skills for software launches and backlink opportunities.

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.

pstack is a skill stack of 63 markdown instructions and 4 agents that route your goal to specialized workflows: reproduce bugs, architect designs, race candidate solutions, review diffs, and polish prose. It runs locally without telemetry, injecting its mandate via SessionStart hook and shell scripts for PR orchestration and worktree auditing.

memsearch is a Claude Code plugin that automatically captures and indexes session summaries across conversations, enabling Claude to retrieve relevant past work when starting new sessions. It uses local ONNX embeddings (no API key required) and integrates with Claude Code's hooks and skills system to maintain a searchable semantic memory of your project history.

TDD Guard enforces Test-Driven Development principles by intercepting file edits and writes in Claude Code to block operations that skip tests or over-implement. It auto-detects your test framework and validates changes against TDD rules using hooks that run on tool use, session start, and user input.

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.

The prompt-improver plugin evaluates user prompts at submission and tool-use time, asking clarifying questions for vague requests and routing complex tasks through targeted nudges like plan-mode assessment, workflow guidance, and subagent orchestration. It uses a skill-based architecture with hook-level evaluation to improve Claude's first output and reduce correction round-trips.

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.

Hivemind provides cloud-backed persistent memory using Deeplake, allowing you to read, write, and share memory across multiple Claude Code sessions and agents without losing context between interactions. The plugin uses hooks to automatically capture session events and tool usage, enabling seamless memory persistence throughout your workflow.

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.

brooks-lint performs AI code reviews against six decay-risk dimensions synthesized from twelve classic engineering books, annotating findings with citations, severity levels, and remedies. It offers six analysis modes (PR review, architecture audit, tech debt assessment, test quality, health dashboard, auto-fix) grounded in proven software engineering principles.

Engram is a learning system that turns Claude into a Socratic tutor, verifying your understanding through free-recall challenges and scheduling review sessions using FSRS-4.5 spaced repetition. It keeps you accountable to what you actually learn—with receipts—across nine agentic platforms including Claude Code, OpenAI Codex, OpenCode, and multiple others.

A universal Claude Code workflow plugin with 7 specialized agents (code-reviewer, debugger, docs-writer, security-auditor, refactorer, test-architect, orchestrator), 26 commands, and 14 skills for automating code review, testing, debugging, documentation, security audits, and refactoring across any software project. It integrates with bash and Python, runs hooks on key workflow events, and is compatible with Claude Code, Cursor, Codex, and 35+ AI agents via skills.sh.

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 intercepts write operations and blocks a predefined list of AI buzzwords before they're used, helping developers maintain more authentic language in their code and documentation. It leverages Python-based hooks to filter and flag overused terminology in real time.

This plugin reviews changed code for redundancy, reuse opportunities, and over-engineering, then applies simplification fixes automatically. It runs as a pre-tool-use hook and uses Python to analyze and refactor code.

Tavily web search and content extraction MCP that provides intelligent web search capabilities and content extraction through model context protocol integration. Includes smart tool selection hooks to automatically route web-related tasks to the appropriate Tavily methods based on context.

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.

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.

deja-vu indexes past coding sessions across 34 supported agents (Claude Code, Cursor, Qwen, OpenClaw, Copilot) and surfaces relevant context automatically using local BM25 search before you ask, with credentials redacted at index time. The plugin integrates via 5 hooks (SessionStart, PreToolUse, PostToolUse, PreCompact, UserPromptSubmit), an MCP server, and a /deja command to query your session history without external APIs or embedding services.

This plugin enables Claude to build and modify Power Apps Canvas Apps by connecting to an app open in Power Apps Studio via the Canvas Authoring MCP server. The agent can create screens, configure controls, set up formulas, manage connectors, and define data sources directly within the Power Apps environment.

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.

FDEOps is a Claude Code plugin that maintains a persistent engagement memory (the "fieldbook") for Forward Deployed Engineers, consultants, and agency developers, organizing client work across phases (land, discover, plan, build, ship, close) and automatically loading context from prior sessions. The @fde skill routes work through the methodology while capturing decisions, debriefs, and stakeholder updates in a local .fde/ directory that persists across coding agents.

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.

fable-baton orchestrates Claude Code sessions with Fable 5 as the decision-maker while routing labor to tiered subagents (Opus/Sonnet/Haiku) based on task complexity and cost. It enforces delegation through session policies, per-prompt reminders, and activity-triggered notices to prevent the model from reverting to expensive inline work.

Hyperflow is a multi-agent orchestration plugin that chains eight slash commands—spec, scope, dispatch, audit, deploy, trace, scaffold, and cache—into a structured engineering pipeline with cross-session memory and adaptive flow profiles. Every step assigns persona-stitched workers with multi-level thinking-model review, parallel task execution, and automatic triage to match task complexity to cost-effective model allocation.

screenshot-janitor automatically detects screenshots created during each Claude Code session and prompts you at the end to move them safely to the Trash rather than cluttering your Desktop. Files are moved (never permanently deleted) using system Trash with zero external dependencies, supporting both macOS and Linux.

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.

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.

Open Steps provides plain-language session reports, operator instructions, and decision framing to make AI-driven development transparent to non-technical builders who run the agent but don't read code. It transforms technical jargon and commit details into clear verdicts on whether work is done, what's needed next, and what new technical debt was created.

VibeWise is a Claude Code plugin that guides you through software design decisions before implementing code, asking you to articulate your approach and tradeoffs at each step. Claude writes the code based on your confirmed design and explains the changes, helping you learn architecture and planning while maintaining control over decisions.

GodotPrompter is a Claude Code plugin that equips AI agents with 55 domain-specific skills for Godot 4.x game development, covering architecture, gameplay systems, physics, animation, networking, and both GDScript and C# patterns. When activated, it automatically detects Godot projects and injects skill-routing guidance that helps agents follow Godot best practices instead of generic coding advice.

claude-council is a Claude Code plugin that queries multiple AI coding agents (Gemini, OpenAI, Grok, Perplexity, Kimi, OpenRouter-routed models, and local Ollama) in parallel and displays their responses side-by-side with a synthesis of agreements and divergences. It helps developers cross-check coding decisions, debug problems, and review security by consulting diverse AI perspectives without requiring any API keys if using local tools or CLI-based providers.

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.

Hippo Memory is a biologically-inspired memory system for Claude Code that learns from errors and past sessions, using decay, retrieval strengthening, and sleep consolidation to maintain relevant context. It automatically injects session-start context, pins key rules on every prompt, captures and prioritizes failures with 2x decay, and compacts transcripts while preserving working state—all locally without external API calls.

PM-Skills is a curated library of 68 best-practice product management skills covering the complete product lifecycle (discover through iterate), plus 6 sub-agents, 12 workflows, templates, and 200+ sample outputs that establish quality standards. It integrates with Claude Code, Codex, Cursor, Windsurf, Copilot, and Gemini CLI via slash commands, workflow orchestration, and skill chaining.

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.

The Shopify AI Toolkit plugin gives Claude Code agents access to Shopify documentation, GraphQL/Liquid/UI extension code generation and validation, and store management capabilities through the Shopify CLI. Skill scripts send usage telemetry to shopify.dev by default, which can be disabled via environment variable or opt-out file.

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.

bounty-board scans your repository for TODO/FIXME/HACK comments and skipped tests, pricing each as an aging bounty whose XP grows with git-blame age, then injects the top 3 as side quests and verifies payouts when markers disappear. It integrates via SessionStart, PostToolUse, and SessionEnd hooks to track your tech debt as a gamified burn-down economy.

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 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.

The plugin mines Claude Code session transcripts via hooks on stop/compact events to extract and record approaches that were tried then reverted, storing reason and token cost in a per-repo registry. It then injects "already tried" warnings on matching prompts and asks for confirmation before edits reintroduce previously-reverted code hunks.

dead-rules-audit passively audits compliance with CLAUDE.md rules by hooking into Claude Code's edit events (SessionStart, PostToolUse, SessionEnd) and tracks violations with deterministic keyword matching, then renders a worst-first scorecard highlighting chronically-ignored rules. All analysis happens locally with zero network calls or external dependencies beyond Node.js.

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.

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.

Standup-autopilot captures what agents actually accomplished from session transcripts—tasks, test results, branches, and blockers—and rolls them up into a daily standup card without relying on commits or tickets. It snapshots each session's outcome at Stop/SessionEnd events, redacts credentials before storing, and re-injects previous blockers on SessionStart to keep the agent context current.

Allium is a specification language and Claude Code plugin that maintains a formal behavioral spec alongside code, using agents to elicit requirements forward from intent or distill them backward from existing code, then generates tests and catches design gaps through CLI validation. It closes the agentic coding loop by providing a persistent, formally-verifiable contract between spec, tests, and implementation that survives across sessions.

A Claude Code plugin that orchestrates full album production from concept to release, coordinating research, lyrics, Suno music generation prompts, audio mastering, and promo materials through 53 specialized skills and an 80+ tool MCP server. Multi-model coordination routes creative tasks (lyrics, concepts) to Opus, reasoning work to Sonnet, and mechanical operations to Haiku.

Episodic Memory enables semantic search across Claude Code, Codex, Cursor, opencode, and Oh My Pi conversations, allowing AI assistants to recall past discussions, decisions, and architectural patterns to provide more informed suggestions across sessions. The plugin automatically indexes conversations at session end and exposes natural language search capabilities through MCP tools to find relevant context even when exact keywords weren't used.

This plugin provides structured implementation planning with interactive annotation review and autonomous plan execution capabilities. It uses a command, agent, skill, and hook (on PreToolUse) to guide multi-step workflows, requiring only python3.

Chisle reduces Claude's output tokens by 44% on coding tasks through zero-fluff prose rules, YAGNI-first code decisions, and aggressive tool-output compression injected per session. It auto-detects 11+ agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot, OpenCode, Hermes) and rewires each with a single command.

Maestro is a multi-agent development orchestration platform that coordinates 39 specialist agents through a 4-phase workflow (design dialogue, design review, implementation planning, and execution) with native parallel subagent dispatch and persistent session management. It provides standalone commands for code review, debugging, security audits, performance analysis, SEO audits, accessibility audits, and compliance checks, all powered by a Node-based MCP server.

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.

AgentOps provides engineering guidance for Claude Code agents through behavior-driven planning, shared domain language, and independent validation mechanisms. The plugin includes 4 agents and 29 reusable skills that enforce policies via hook-based dispatching to improve coding agent reliability and consistency.

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.

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.

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.

EvanFlow is a TDD-driven orchestration system with 16 skills and 2 custom subagents that guides software development from brainstorm through implementation via checkpoints (design approval, plan approval, post-iteration review), ensuring you stay in control without auto-commits. The loop runs vertical-slice TDD per task, supports parallel coder/overseer review for independent units, and stops short of every git operation to await your direction.

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.

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.

This plugin provides guardrails and debugging tools for research workflows, catching AI mistakes in paper reproduction and experiment tracking before they become costly. It includes citation validation, LaTeX checking, timezone handling, and evidence-first experiment comparison through shell-based guards and hooks.

A Claude Code plugin and agent skills toolkit that teaches Claude to author, validate, and visualize Open Knowledge Format (OKF) bundles—portable markdown knowledge with YAML frontmatter that humans and agents can both read and maintain. Includes a deterministic conformance checker, interactive graph renderer, GitHub Action support, and an MCP server for read-only knowledge access.

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.

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.

Architecture Studio is a local-first framework for AEC firms to build governed AI workflows with persistent studio and project memory, bundling 7 agents and 50 skills for site planning, zoning, specifications, sustainability, and materials research. The plugin initializes portable workspaces, maintains linked project records, and provides extension points for firm-specific and project-specific skills that remain user-owned outside the plugin cache.

AI Team OS transforms Claude Code into a multi-agent team operating system with 155 MCP tools, 25 agent templates, persistent task management, and autonomous loop execution across lifecycle hooks. It coordinates complex projects through team orchestration, task walls, meetings, memory store, and a company-style execution engine with health monitoring and self-healing capabilities.

This Claude Code plugin integrates the Antigravity CLI (Gemini) as a collaborating sub-agent, routing deterministic, high-volume work (scaffolding, test generation, migrations, web/Vertex AI Search) to Gemini while Claude handles requirements, architecture, verification, and review. Hybrid agentic engineering reduces token costs by routing cheaper bulk work to Gemini while keeping the hard judgement calls on Claude.

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.

Abstract provides meta-skills infrastructure for authoring and evaluating Claude Code plugins, including modular design patterns, hook development frameworks, and quality validation tools. It includes skills like methodology-curator, modular-skills, and skills-eval, plus agents for plugin validation and architecture review.

Cartograph generates architecture, data flow, dependency, call chain, class, and community detection diagrams from codebases by analyzing code structure and rendering visualizations via Mermaid Chart MCP. The plugin provides `/visualize` commands that dispatch a codebase explorer agent to analyze modules and relationships, then synthesize Mermaid diagram syntax for rendering.

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.

Gauntlet extracts code structure via AST analysis and builds a knowledge graph to generate adaptive coding challenges using spaced repetition, helping developers prevent knowledge atrophy and accelerate onboarding. It supports six challenge types—multiple choice, code completion, trace, explain-why, spot-the-bug, and dependency mapping—with ML-based answer scoring and pre-commit hooks to gate commits behind knowledge checks.

Imbue provides structured analysis methodologies and workflow guards for evidence-backed code review, change analysis, and feature prioritization using RICE/WSJF/Kano scoring frameworks. It enforces best practices through PreToolUse hooks that validate assumptions, prevent package hallucination, gate feature scope creep, and maintain audit trails across git diffs, specifications, and logs.

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.

Memory Palace organizes domain knowledge using spatial mnemonic techniques, building persistent "palaces" and "gardens" with multi-modal search, bidirectional linking, and automatic deduplication. It captures PR review knowledge and intercepts web requests to check local knowledge before external lookups.

OpenQodex is a Claude Code plugin that runs security and lint scanners (Semgrep, Gitleaks, OSV-Scanner, ShellCheck, Ruff) on your changed code, then spawns a separate Claude reviewer that validates each finding and generates a unified report. It integrates with git pre-push hooks to enforce review policies and runs entirely on your own Claude login with no external API keys required.

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.

Pensive is a reflective code review toolkit for Claude Code that orchestrates domain-specific reviews (Rust, APIs, tests, architecture, blast radius, math, shell scripts) with structured analysis and intelligent skill selection. It identifies code quality issues, security vulnerabilities, and architectural risks through specialized agents, producing actionable findings with severity rankings and remediation steps.

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.

Tome runs autonomous research across code repositories, community discourse, academic literature, and TRIZ cross-domain analogical reasoning, then synthesizes findings into domain-appropriate reports with adaptive depth and bibliography generation. It integrates with memory-palace for knowledge export and uses GitHub, Hacker News, Lobsters, Reddit, arXiv, and Semantic Scholar as primary research channels.

A token-efficient communication plugin that reduces Claude's output by ~75% while maintaining technical accuracy, optimized for Japanese with features like caveman-style compression, commit generation, and PR review. Includes 3 sub-agents (investigator/builder/reviewer), 6 slash commands, and automatic mode tracking via SessionStart and UserPromptSubmit hooks.

Pordee is a Claude Code plugin that compresses Thai language responses by removing politeness particles, filler words, and unnecessary grammar while preserving technical accuracy, reducing output tokens by 60–75%. It operates through slash commands (/pordee, /pordee lite, /pordee full) and keyword triggers, offering two compression levels with a session statistics feature.

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.

Naksha is a virtual design team plugin that assembles 30 specialist roles (UI designer, UX researcher, content designer, Figma expert, motion designer, and more) for Claude Code and other coding assistants, offering 70 slash commands and 16,000+ lines of design expertise. The plugin activates automatically based on what you're building, integrating design system tokens, component frameworks, accessibility compliance, and multi-channel content creation into your coding workflow.

This plugin implements a two-loop skill pipeline that catches failures during Claude Code sessions through an inner loop of planning, intent-framing, context-surfacing, verification, and self-healing, while an outer loop learns from recurring patterns to promote permanent rules and regression tests. It hooks into session lifecycle and tool-use events to provide active runtime recovery, including automatic remediation when commands, tests, builds, or external services fail mid-task.

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.

Lumen is a 100% local semantic code search engine for Claude Code that indexes your codebase using Go AST parsing and embeds code with Ollama or LM Studio, reducing API costs by up to 39% and token usage by up to 66% compared to baseline AI coding workflows. It exposes vector search through an MCP server with no cloud dependency, external API keys, or npm requirements.

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.

Codebase Mapper automatically creates and maintains a current map of your project structure that Claude loads at the start of each session, tracking files, flows, dependencies, and conventions across any stack. It monitors code changes throughout sessions and keeps the map in sync with incremental or full updates as needed, eliminating the need for Claude to rediscover your codebase each time.

Live Rules keeps project instructions in front of Claude Code by storing atomic rules in .claude/live-rules/rules/ and injecting them at SessionStart and when prompts or edits match. Rules are authored in natural language via the add-rule skill and automatically managed as individual Markdown files with a generated manifest for efficient, content-aware delivery.

Model Gateway adds GPT and Grok models to Claude Code's /model picker via a local proxy that routes requests to OpenAI and Grok while keeping Claude models on Anthropic. The plugin requires Node.js and your own ChatGPT/Codex or Grok subscriptions; no API keys are stored in the plugin itself.

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.

Sidequest is a self-hosted Kanban board and orchestration system for Claude Code that persists tasks across context compaction and sessions, automatically routing tickets to executors for verification and review. It provides a local dashboard for planning, tracking, and delivering work with categories, dependencies, and discussion threads that survive chat context shrinking.

Designpowers is a 10-agent design system that runs an inclusive design workflow—discovery, research, strategy, design, build, and review—with accessibility integrated at every step and you as creative director approving or redirecting at each handoff. The plugin works with any AI coding tool via markdown skills and agents, supporting both Direct mode (approval at each step) and Auto mode (full pipeline with end review).

ed3d-basic-agents provides three core agents and two skills for general-purpose tasks that serve as dependencies for other plugins. It runs shell commands during session initialization without requiring external API keys.

This plugin captures session metadata at startup and provides tools to review Claude Code conversations—analyzing prompting effectiveness, agent performance, and environment gaps through dispatched Opus reviewers that read token-reduced transcripts and write structured findings. For multi-session analysis, it synthesizes cross-session patterns to identify recurring issues and highest-impact recommendations.

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.

AgenticMail gives each Claude Code agent its own real email address and phone number, with email coordination between agents running as subagents under a shared Anthropic OAuth token. All data stays self-hosted on the user's machine, with agent dispatch triggered by incoming mail over real SMTP/IMAP backed by Stalwart.

skills-for-humanity is a structured toolkit of 200+ invokable reasoning methods organized across 34 domains (logic, ethics, creativity, decision-making, systems thinking, communication, and more), each applying a specific framework to help Claude think more rigorously about problems. The plugin runs these methods as commands prefixed with `/s4h-`, allowing users to apply history's most rigorous thinking procedures repeatably, inspectably, and composably.

deep-project transforms vague, high-level software project requirements into well-scoped planning units through AI-assisted interview and decomposition, producing focused spec files ready for /deep-plan. It orchestrates a workflow of structured Q&A, split analysis, dependency mapping, and spec generation to break large projects into manageable components.

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.

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.

DevGlobe shows your coding activity on a live interactive globe while you work with Claude Code. The plugin tracks tool usage and prompt submissions to update your presence on a global map in real-time.

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.

claude-carbon tracks the CO2 emissions of Claude Code sessions with live estimates displayed in the terminal status line and a dedicated desktop app pane showing historical usage patterns. It persists session data locally to a SQLite database, backfills history from existing transcripts, and provides slash commands for carbon reports, PNG cards, and pull request footprint analysis.

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.

alcoa-guard is a deterministic ALCOA+ data-integrity linter that checks Attributable, Contemporaneous, Complete, Accurate, and Consistent properties in code while surfacing human-judgment items (authorization, gap justification) as a checklist for manual review. It runs standalone against CSV/JSON records with a declared contract or integrates with agentic-sop-kit run directories, outputting a DRAFT report that requires human verification.

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.

Second Opinion is an independent adversarial honesty reviewer that checks whether claims in a DRAFT output are backed by evidence, catching fabrication, transcription errors, invented IDs, and unsupported conclusions via deterministic code checks plus a capped advisory LLM pass. The plugin runs in FULL mode against agentic-sop-kit run traces or DEGRADED mode against any document with user-supplied inputs, always producing an advisory DRAFT report that a human must review and approve.

Hipocampus provides persistent agent memory across sessions via a 3-tier auto-compacting architecture that maintains a scannable topic index (ROOT.md) alongside hybrid search capabilities. The system enables agents to proactively recognize connections between past context and new requests without explicit search queries, achieving 21.6x better performance than no memory on implicit context retrieval tasks.

WOZCODE is a Claude Code plugin that replaces built-in file tools with token-optimized alternatives for coding, searching, batch editing, and SQL introspection while reducing session cost. The plugin includes a fast codebase explorer subagent and automatically delegates tasks, with savings tracked via login credentials.

Total Recall is a persistent memory system for Claude Code that saves only behavior-changing facts through a curated write gate, using a tiered architecture of daily logs, structured registers, and auto-loaded working memory. The system prevents memory bloat by requiring saved notes to pass gates about behavioral impact, commitments, decisions, or stable facts—keeping the AI focused on what actually matters across sessions.

Claude Remember hooks into your coding sessions to automatically save, compress, and summarize conversations into tiered daily logs using Claude Haiku. On the next session start, it injects your compressed memory history into context so the agent begins with awareness of previous work, decisions, and lessons learned.

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.

A complete AI-powered patent creation and analysis system that helps inventors search prior art, draft claims, and prepare applications without legal experience through guided workflows and automated validation. It integrates 16 commands, 13 agents, and 17 skills to handle patent rule lookup, prior-art searches across 100+ million patents, document review, and diagram generation entirely within Claude Code with no external MCP server required.

Meridian is an enforcement framework that injects persistent project context, manages planning gates, and learns from sessions to keep Claude Code oriented across long tasks and multiple sessions. It scaffolds a `.meridian/` workspace directory with docs, prompts, and configuration that automatically resurface relevant guidance at key lifecycle moments like session start, tool use, and task completion.

A Claude Code plugin specialized in ADVPL and TLPP for TOTVS Protheus development, offering code generation, ADVPL-to-TLPP migration, error diagnosis, code review with 24 best-practice rules, and automated documentation. It also provides dictionary generation (SX2, SX3, SIX, SXG, SXA, SX1, SX5, SXB, SX7) for functional consultants and supports automatic CP1252 encoding conversion for all ADVPL/TLPP file types.

This Claude Code plugin provides 14 curated agent skills for CesiumJS v1.143 development, covering ~551 public symbols across domains like 3D tiles, imagery, terrain, camera control, and spatial math. The skills integrate with Claude Code and follow the open Agent Skills standard for browser-based iteration via Chrome DevTools.

cc-polymath is a skill management system that organizes 410+ production-ready development skills across 33+ domains into atomic, composable units with progressive discovery via keyword-triggered gateways. It solves context-window efficiency by loading only relevant skills on-demand rather than upfront, reducing startup overhead by 60-84% compared to monolithic knowledge bases.

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.

prd-ce is a PRD lifecycle methodology engine that scaffolds PRD/SoT/EPIC documents to template and drives them toward completion using 4 agents and 50 specialized skills organized by stage. It governs the process with 6 hooks into the Claude Code runtime and deterministic readiness scoring.

The VGV AI Flutter Plugin is a Claude Code plugin with 15 best-practices skills covering Flutter and Dart development (accessibility, animations, BLoC, testing, theming, navigation, security, internationalization, layered architecture, license compliance, UI packages, SDK upgrades, and more) plus an autonomous quality-gate loop that drives code analysis, formatting, testing, and coverage to green. It runs locally via bash, dart, and the very_good CLI without requiring API keys or external paid services.

A Claude Code plugin delivering 15 best-practices skills and a Flutter reviewer agent for accelerated Dart/Flutter development, including accessibility, animations, testing, BLoC, theming, security, and an autonomous quality-gate loop that drives code to green. The plugin requires the Very Good CLI and Dart toolchain, enforces standards via pre/post hooks, and includes a specialized reviewer agent for security and accessibility auditing.

cc10x is a specialized routing harness for Claude Code that distributes requests across eight specialist subagents (build, debug, review, plan, QA, orient, triage, codebase health) with gated workflows, persistent artifacts, and memory preservation. The plugin coordinates multiple agents through hooks and guardrails to ensure fail-closed operation and honest test reporting with fresh-context verification.

This Claude Code plugin automatically maintains CLAUDE.md project memory files as codebases evolve, tracking file edits, deletions, and moves through hooks and updating memory in an isolated agent to preserve context window. It offers zero-config initialization, git-aware syncing, and marker-based updates that preserve manual content while keeping build commands, architecture, and conventions fresh.

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.

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.

The atdd plugin enforces Acceptance Test Driven Development methodology by translating domain-language acceptance criteria into executable Gherkin specifications and generating a project-specific test pipeline with dual acceptance and unit test streams. It integrates with the broader Disciplined Agentic Engineering (DAE) framework to maintain deterministic guardrails and audit trails throughout the feature development lifecycle.

A Claude Code plugin that provides 18 structured workflow skills for guiding AI through design, implementation, code review, testing, and documentation phases. Includes domain-specific profiles (Go, Java, JS/TS, Kotlin, K8s, Python) with checklists, validators, and review rubrics.

NLPM scores, checks, fixes, and tests natural-language artifacts (skills, agents, commands, rules) across Claude Code, Codex CLI, and Antigravity with tier-aware validation and manifest-vs-disk consistency detection. It provides eight slash commands for linting NL artifacts, a standalone Python validator for CI/pre-commit pipelines, and a self-evolving GitHub Actions auditor that harvests teaching examples from clean repos.

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`.

Unslop removes AI-characteristic patterns like sycophancy, stock phrases, hedging, and em-dash overuse from Claude output while preserving code, URLs, and technical accuracy. It works as a Claude Code plugin with session hooks that intercept and rewrite text to sound more naturally human.

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 Claude Code plugin automatically generates and maintains a fractal multi-level documentation system inspired by Gödel, Escher, Bach, creating self-referential PROJECT_INDEX, FOLDER_INDEX, and file-header annotations that keep code and documentation in perfect sync. It uses post-tool hooks to detect code changes and automatically regenerate the interconnected index structure across the entire project.

Superpowers Optimized is an agentic development framework for Claude Code that adds automatic 3-tier workflow routing, TDD enforcement, 10 proactive safety hooks, and cross-session memory to enforce disciplined coding practices. It features built-in security review with OWASP checklists, adversarial red-teaming, and systematic debugging across 24 specialized skills.

Clay is a plugin that adds 31 skills to Claude Code for building applications, integrated via hooks that monitor tool usage. It requires approval CLI scripts and shell execution capabilities to function.

Vibes is a GUI framework for Claude Code that lets non-programmers build multi-user web apps as single HTML files with embedded TinyBase databases and real-time sync. Users describe their app idea, and Claude generates a complete, deployable application without requiring backend setup or server management.

Governor optimizes Claude Code sessions through tool-output filtering, context compression, and drift guardrails, while also providing prompt-based rules for context hygiene in other AI coding agents like Cursor, Windsurf, and Cline. It maintains decision quality and unique data integrity while reducing token waste from verbose tool output and recurring context overhead.

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.

Claudikins Kernel is a disciplined workflow engine for Claude Code that enforces a strict 4-stage pipeline (outline → execute → verify → ship) with gates between each step, preventing shortcuts and ensuring quality through specialized AI agents. Each stage has distinct roles like the taxonomy-extremist researcher, babyclaude implementer, and catastrophiser verifier that work in parallel with shell-based validation hooks to maintain SRE discipline.

HyperGrok transforms Claude into a Hyperliquid trading desk with seven specialist agents (Desk Lead, Market Analyst, Research Analyst, Strategist, Risk Manager, Execution Trader, and Review Officer) and seventeen skills for research, risk management, execution, and review. It starts read-only on public market data and requires user approval for live trading via API wallet integration.

claude-mega-brain injects a compressed OKF-formatted knowledge index into Claude Code sessions automatically, enabling accurate project-specific answers without tool calls. The plugin scans for markdown files with YAML frontmatter type declarations and injects the consolidated knowledge at session start and after tool use.

A comprehensive Claude Code plugin that integrates Remotion with a full suite of video production tools—including video analysis, TTS voiceovers, music/SFX generation, stock footage search, AI image/video synthesis, animated captions, and professional transitions. It automates the entire pipeline from concept to render through MCP servers and command-driven agents powered by ElevenLabs, TwelveLabs, Pexels, KIE, and Replicate.

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 monitors competitor content across X, Instagram, TikTok, and YouTube to identify high-performing posts and surface actionable content ideas ranked by engagement data. It learns your brand's voice and niche through your own channel analysis, then personalizes idea recommendations while filtering out content you've already made.

A Claude Code plugin providing interactive onboarding and Q&A skills for mastering Claude Code setup, best practices, automation, and effective workflows. Includes seven skills ranging from interactive guides to introspective development audits and a gamification system that tracks feature usage across sessions.

Agentic-Security automatically scans code for security vulnerabilities (SAST, SCA, secrets detection) using plain-English risk explanations with cost estimates, and can automatically verify and apply fixes before they touch disk. It integrates directly into Claude Code as a plugin or runs standalone via CLI with multiple output formats (HTML, JSON, SARIF, CSV).

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.

motiscope analyzes screen recordings of animations to extract precise timing, easing curves, and keyframes, then generates working code in GSAP, CSS, Framer Motion, or Lottie. The tool runs locally with ffmpeg and Python standard library, requiring no cloud accounts or external services, and works as a Claude Code plugin or portable agent skill.

Context Optimizer monitors Claude API usage, shows real-time costs and token consumption, and automatically routes cheap work to Haiku 5.5 subagents to reduce spending. It provides five reusable skills for chat and Claude Code (fresh-start, doc-digest, project-context, token-check, sharpen-prompt), a live meter displaying context usage and cache countdown, and audit tools to analyze spending patterns across sessions.

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.

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.

Matrix gives Claude Code persistent memory and deep code intelligence through semantic search and tree-sitter indexing across 15 languages, with hooks for pre-emptive issue detection and code review. Features include solution recall, symbol navigation, CVE warnings, and dead code detection—all stored locally with no external API calls.

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.

ALDC is an AI-native development toolkit for Microsoft Dynamics 365 Business Central offering 10 agents, 15 knowledge skills, and TDD-driven workflows for extension-only development with code review, event-driven architecture patterns, and human-in-the-loop gates. It includes specialized agents for architecture, development, test-driven delivery, pre-sales estimation, and agent building, plus MCP servers for AL symbol resolution and documentation lookup.

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.

opentrace-oss is a Claude Code plugin that exposes a knowledge graph for exploring system architecture, code structure, and service dependencies through graph query tools. Once a codebase is indexed, users can ask Claude questions about code structure, dependencies, and architecture using specialized agents like @code-explorer, @dependency-analyzer, and @find-usages.

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.

Superloopy is a lightweight loop harness for Claude Code that orchestrates agents and skills to execute tasks while proving completion with real evidence artifacts stored in `.superloopy/evidence/`. It requires Node.js and supports evidence-backed criteria plus optional subagents, hooks, and specialized skills for research, backend, frontend, and cloning workflows.

A DeepSeek-Claude bridge plugin that enables code review, critique, and task delegation between the two AI models within Claude Code. It provides 10 commands, 1 agent, and 2 skills to coordinate workflows between DeepSeek and Claude using Node.js and local shell execution.

Bedrock automates Obsidian vault management by turning markdown notes into a structured knowledge graph with AI-powered entity detection, bidirectional linking, and sync across 7 entity types. It ingests external sources (Confluence, Google Docs, GitHub, PDFs, and more), deduplicates content, and provides orchestrated querying through Claude Code skills.

The ai-literacy-superpowers plugin provides a complete AI engineering and development workflow framework incorporating literate programming, CUPID code review principles, agent orchestration, and three enforcement loops for compound learning. It includes 32 commands, 20 agents, and 41 skills to support engineering practices from development through code review and iteration.

deep-plan transforms vague feature requests into detailed, production-ready implementation plans through AI-assisted research, stakeholder interviews, and multi-LLM review. The plugin orchestrates a comprehensive workflow including research, interview, external LLM review, TDD planning, and section splitting to create isolated, parallelizable implementation units.

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 plugin intercepts the agent's plan-writing mode and opens a local browser UI where you can annotate plans with strikethroughs, replacements, insertions, and comments before approving or requesting revisions. All processing runs locally with no external service dependencies, and the agent iterates on your feedback until the plan is approved.

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.

Buildomator is a Claude Code plugin that automates structured workflows with planning, execution, and verification phases while keeping project state in an MCP-backed store and minimizing token overhead. It breaks complex work into focused subcontexts with agent skills for research, implementation, and testing, asking you only about design decisions that require human judgment.

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.

Buildomator is a Claude Code plugin that orchestrates project planning, execution, and verification through structured workflows with MCP-backed state management and automatic context resumption. It optimizes token usage (~92% reduction in per-turn overhead) by splitting work into focused subcontexts and asking for human input only on architecture decisions.

This Claude Code plugin provides comprehensive Shopify development reference documentation covering Liquid templating, Online Store 2.0 themes, Hydrogen framework, app development, and Functions, while deferring live GraphQL schema validation to Shopify's official tools. It includes reference materials on theme performance, debugging, API versioning, and migration guidance for deprecated features like Scripts and Hydrogen API changes.

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 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.

claude-brain automatically syncs your Claude Code memory, skills, agents, rules, and settings across all your machines using Git and semantic merge, eliminating the need to re-teach Claude on each device. It runs hooks on session start/end for zero-effort cross-machine knowledge evolution with intelligent conflict resolution.

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.

Grainulator is a research sprint orchestrator for Claude Code that conducts multi-pass investigations with typed claims, evidence tiers, tension detection, and confidence scoring to produce compiled, high-confidence answers in under 60 seconds. It structures research findings as factual, constraint, risk, recommendation, or estimate claims, detects contradictions, and synthesizes results through a 7-pass compiler that grades evidence strength and produces 0-100 confidence scores.

winnow is a context optimization plugin for Claude Code that intelligently filters large tool results (Read, Bash, Grep) by using a fast System One model judge to identify irrelevant blocks, replacing them with summaries and recall keys to save tokens. The plugin operates as a function hook that intercepts tool results before they enter Claude's context, allowing full text to be recovered on demand while keeping the conversation focused on what matters.

Gangsta is an AI agentic skills framework for spec-driven development that organizes six specialized agents in a mafia-hierarchy model with phases spanning reconnaissance, adversarial brainstorming, formal spec drafting, task decomposition, parallel execution, and delivery. The framework enforces strict governance rules (Omerta), maintains institutional memory via a Family Ledger, and gates every phase with developer approval.

Swarm assembles multi-agent teams (engineers, security reviewers, business stakeholders) to autonomously research, debate, build, and peer-review code tasks until they meet ship-ready standards, then deliver a final PR for your approval. The plugin runs unattended for hours or days, survives interruptions, and uses outcome-framing instead of implementation steps to guide team deliberation toward better solutions.

Funnel Architect transforms Claude into a full-stack sales funnel architect, generating production-ready pages, conversion copy, and deploying to Vercel, Netlify, or Cloudflare using 5 specialist agents and 29 skills covering 13 funnel types. It automates strategy, design, copywriting, performance optimization, and deployment with integrated payment processing via Stripe.

Pensyve is a persistent memory layer for Claude Code that captures decisions, debugging outcomes, and project context across sessions without explicit invocation. It uses local SQLite-backed embeddings with multi-signal retrieval to proactively ground substantive work in prior lessons while keeping simple commands fast.

ResumeHQ is an AI-powered resume builder that discovers live job listings, scores candidate fit using deterministic engines (not LLM guessing), and auto-tailors resumes with a fail-closed auditing pipeline that refuses to fabricate experience. It produces Workday-compatible DOCX output, generates cover letters, and auto-detects 6+ professional domains while publishing its own scoring benchmarks including failures.

Claude Gladiator hooks into tool execution to observe failure patterns and prompt reflection before session ends, using an MCP server to cluster observations into learning recommendations. It runs silently on success and only processes errors, with minimal token overhead (~100-200 per session).

Claude Historian automatically searches past sessions before web research, planning, and debugging to avoid redundant work. It uses an MCP server to inject history-checking logic at key decision points, reusing prior solutions and decisions when available.

Claude Oracle automatically discovers skills, plugins, and MCP servers across 17 community sources by searching at high-impact moments like planning and error recovery. It integrates via hooks that trigger search before planning and after errors, returning install commands for immediately relevant tools.

Claude Orator is a prompt optimization coach that deterministically scores and restructures prompts using Anthropic best practices without making LLM calls or network requests. It runs as a PreToolUse hook to suggest improvements for under-specified subagent prompts and includes a command for manual prompt optimization across 7 dimensions (clarity, specificity, structure, context, examples, constraints, tone).

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.

This plugin teaches Claude to prefer the iq CLI for agent-native workspace search over grep/find/Glob, and adds session recall capabilities to retrieve past-session files by topic and fork sessions mid-conversation. It ships as a skill with SessionStart and UserPromptSubmit hooks that automatically suggest features like past-session topic→file search and mid-point session forking based on matching first prompts.

This Claude Code plugin provides comprehensive Jira integration through two specialized skills: jira-communication for API operations via Python CLI scripts, and jira-syntax for wiki markup and validation. It auto-discovers issues from context, works with both Jira Server/DC and Cloud deployments, and requires only Python 3 with no external API keys or MCP overhead.

This plugin analyzes Shen Lun (申论) examination materials, provides corrective feedback on responses, and assigns structured scores while enforcing safe execution. It integrates Python3-based processing through an MCP server and a PreToolUse hook for validation.

Tyran is a multi-agent orchestration plugin for Claude Code that assigns distinct subagents to different work streams with model tiers matched to task difficulty, maintains a persistent journal and retrospective learning system in your repo, and enforces evidence contracts through pre-execution hooks on tool use, writes, and secrets. It centralizes cost tracking, context management, and decision history on a live dashboard while preventing context sprawl by never letting individual agents accumulate the full transcript of parallel work.

Zero Drift is a Claude Code skill that maintains grounded AI behavior across long sessions by requiring replies to open with your name and maintaining a living TASK.md document that records proven work and current state for seamless context handoffs. When sessions degrade, you can resume from a fresh window by reading the TASK.md file, avoiding repetition and context drift.

ThreatSwarm is an offensive security workspace for Claude Code with 27 specialist agents covering recon, exploitation, and post-exploitation, plus scope enforcement and evidence logging for penetration testing and red-team operations. It provides six engagement commands (engage, attack, pwned, hunt, ir, report) and three hook-based controls that gate tool execution by scope, log all commands, and aggregate findings.

Wenlan is a living knowledge base that agents build during work sessions, with learned insights automatically converted into source-cited wiki pages that persist across threads. Each new session starts with the latest accumulated knowledge from previous agent work.

Wenlan is a local-first knowledge base that agents build autonomously as they work, capturing learnings as source-cited wiki pages that persist between sessions. All data lives on your machine under ~/.wenlan, with memories and pages served by a local daemon that never shares content with Anthropic or external services.

code-graph-mcp auto-indexes your codebase as an AST knowledge graph to enable semantic search, call graph traversal, HTTP route tracing, and impact analysis through MCP tools. The plugin hooks on SessionStart to initialize and expose these code navigation capabilities via an integrated agent.

lintlang audits agent configs, system prompts, and tool definitions by scanning YAML, JSON, Markdown, and Python files, offering both an on-demand audit skill and automatic repair guidance after Claude Code edits supported language-bearing files. The plugin requires Python 3.10+ with lintlang installed via pipx, runs the scanner locally without making network calls, and integrates with Cursor's Agent Plugins in addition to Claude Code.

Wenlan is a living knowledge base that agents build and maintain as they work, automatically creating source-cited wiki pages that persist between sessions and refresh with new discoveries. Each new thread starts from the latest accumulated knowledge, allowing agents to leverage previous learnings and context.

Akii is a free SEO, AEO (Answer Engine Optimization), and GEO toolkit that audits websites, optimizes pages, generates schema markup, clusters keywords, and tracks AI visibility across ChatGPT, Claude, Gemini, Perplexity, Copilot, and Google AI Overviews. The plugin includes 15 skills, 5 autonomous agents, and 8 commands for content strategy, technical audits, and multi-language localization—with optional integration of Ahrefs, GSC, Apify, and DataForSEO MCPs for richer data.

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.

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.

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.

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 feed-to-brief pipeline that fetches, scores, and synthesizes curated news from your chosen sources on a schedule, with story tracking and weekly summaries. It includes source curation tools, a validation system for feed registries, and security controls to prevent fetches from untrusted domains.

Hermitd is an always-on Claude Code agent that runs locally on your machine or server, accessible via the Claude app, Discord, Telegram, or custom channels, with proactive task monitoring, persistent state, and scheduled routines. It integrates with your Claude subscription and can be extended with custom MCP servers, skills, and plugins for continuous knowledge maintenance and system monitoring.

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.

A feed-to-brief pipeline that fetches, scores, and synthesizes curated news briefs from your chosen sources on a schedule, with story tracking and weekly performance analytics. It runs a 7-phase processing workflow (fetch, score, write, deliver, archive, synthesize) backed by source-quality audits and a fetch-guard security hook.

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.

Summer SDK provides 78 game-dev skills, lifecycle hooks, and a 62-tool MCP bridge that connects AI agents to the Summer Engine for building real 2D and 3D games through conversation. The plugin integrates with Claude Code, Cursor, Codex, Devin Desktop, and other AI agents through a single npm package with MIT open-source tooling.

ballast is a Claude Code plugin that helps you build expertise in unfamiliar domains by decomposing goals into foundational steps, then preserves solved paths and rules as persistent knowledge that carries forward to subsequent goals. It delivers standing rules and verified facts into conversations via four hook events (UserPromptSubmit, PreToolUse, PreCompact, SessionStart) and provides sixteen markdown skills for decision tracking, verification, goal decomposition, and knowledge management.

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.

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.

A Claude Code plugin that scaffolds and maintains a `docs/lore/` directory to capture implicit project knowledge—business rules, API quirks, pitfalls, and decision rationale—that code and git history can't reveal. Seven interlinked skills (init, consult, capture, guard, maintain, check, ul) form a self-correcting loop: capture knowledge as you learn it, consult it before acting, guard diffs against it at commit time, and health-check the lore every ~30 days to keep it alive.

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.

This plugin integrates Pinecone's vector database directly into Claude Code through an MCP server, enabling semantic search, RAG workflows, and index management. It provides slash commands for quick operations, support for Pinecone Assistants for document Q&A, and access to core Pinecone tools like index creation, upserting, and querying.

Craft is a Claude Code plugin that enforces a read-only codebase by default, routing all changes through a Write Gate as planned work, while maintaining a local history of project decisions and design tokens that help Claude learn your architectural preferences over time. It ships with 62 commands, 27 agents, 11 skills, and a dashboard that visualizes your project's evolution as an interactive galaxy of interconnected work.

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.

This Claude Code plugin grounds all RuvNet-related decisions in real source code from 77 RuvNet repositories, injecting retrieval-augmented generation via a search_ruvnet tool and hooks that enforce grounding before RuvNet product code is used. It ships 6 commands, 9 skills, 12 hooks, and 1 MCP server to steer Claude toward Ruflo, RuVector-RVF, and AgentDB instead of training-prior defaults like pgvector and Pinecone.

total-agent-memory provides persistent, local memory for Claude Code and other MCP clients through a temporal knowledge graph, procedural memory system, and AST codebase ingest that tracks facts, decisions, and working practices across sessions. It installs as an MCP server with capture hooks that fire on session start/end, tool use, and user input to build and query a searchable local-first knowledge base with optional grounded retrieval and revision history.

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.

This Claude Code plugin enables peer-to-peer communication between separate Claude Code sessions running on the same machine through shell commands and hooks. It uses a SessionEnd hook to manage communication state and coordinate data exchange between concurrent sessions.

Tool Executor is a configurable MCP wrapper that consolidates 96 tools from 7 example servers into 3 discoverable commands (search_tools, get_tool_schema, execute_code) with semantic search and sandboxed TypeScript execution. It reduces token consumption by 97% through lazy loading and batched execution, bridging the gap between the API's programmatic tool calling and Claude Code's serial execution model.

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.

Arxitect is an agentic coding plugin that enforces best-practice software design and architecture by providing specialized reviewers that validate API Design, Object-Oriented Design, and Clean Architecture standards. It includes implementation agents and review skills that help coding agents build robust, maintainable software while reducing context burn and improving code quality.

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.

ClawCode extends Claude Code as a persistent agent plugin, adding memory, personality, voice, and messaging across WhatsApp, Telegram, Discord, iMessage, and Slack with bilingual recall and lifecycle hooks. It runs entirely within Claude Code's plugin system with no separate billing, featuring nightly memory consolidation, slash commands, webhooks, and an optional always-on background service.

The divi5-toolkit is a Claude Code plugin that assists Divi 5 developers with CSS validation, code generation, accessibility auditing, and performance optimization for Core Web Vitals. It provides 10 commands, 5 agents, and 3 skills including setup auto-detection, selector lookup, and project health diagnostics across the latest Divi 5.13 modules and features.

archcore enables spec-driven development and context engineering for AI coding agents by leveraging project context from Git repositories and managing tool execution through pre/post-use hooks. It provides 4 commands and 2 agents to help structure and validate AI-driven code generation workflows.

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.

Eidos enables spec-driven development in Claude Code by treating Markdown specifications as the source of truth, with code as a downstream manifestation that stays bidirectionally in sync. It provides 73 skills organized around core workflows—spec↔code loops, persistent planning and memory, research and understanding, and steering mechanisms—to keep human intent and AI reasoning aligned throughout development sessions.

PagoKit picks the optimal payment provider for your project and auto-generates a complete, secure integration including checkout, webhooks, database schema, and customer portal, backed by deterministic validators that block insecure writes at tool-use time. It knows 42 providers, 136 payment methods, 74 countries, and 106 currencies with their correct exponents, verifying webhook signatures and refund feasibility locally with no external accounts or telemetry.

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.

oh-my-fable automatically injects Anthropic's Claude Fable 5.1 prompting guidelines into Claude Code sessions via a SessionStart hook, with optional commands to transform rough requests into structured prompts and audit rule compliance. The plugin detects session type (interactive vs. unattended) and subagent contexts to apply appropriately scoped versions of the Fable 5.1 guidance without creating or modifying user files.

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.

This plugin maintains a searchable local index of Claude documentation accessible via the /docs command and auto-discovery skills. It automatically updates the documentation on session start and provides instant access to API references, guides, and tutorials without external service dependencies.

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.

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.

Hush is a Claude Code plugin that reduces narrative output and tool verbosity through writing-style controls and session hooks, shortening final answers to focus on results. It trims command output, references full results when needed, and supports customizable voices while maintaining correctness and completeness.

Evolving Lite is a self-improving Claude Code plugin that captures user corrections as learned experiences and injects matching context before future tool calls, with built-in safety guardrails including self-tuning delegation config, progressive activation across sessions, and automated health monitoring. It uses bash for execution and Kairn as a prerequisite memory layer, actively learning from repeated corrections while preventing config drift through loss-fast trust models and no-regression guards.

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.

Mycelium enforces a structured discovery phase before code generation by asking clarifying questions about purpose, assumptions, and validation criteria, then gates the build until answers are provided through 63 skills and 15 theory gates wired as hooks. The plugin installs brownfield-safe without modifying existing project files, shipping versioned capabilities via Claude Code's plugin mechanism.

This plugin implements a self-improving loop for Cowork (cloud container) environments by distilling Claude's experiences into reusable skills and persisting them to claude.ai via SendUserFile, while avoiding SessionStart hook race conditions and ephemeral container storage through UserPromptSubmit guidance and Post-Turn distillation triggers. It is a Cowork-specific variant of claude-code-self-improving-skills that replaces curator functionality with direct skill export to claude.ai's skill management system.

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.

This plugin automatically enhances prompts with composable decorators (reasoning, structure, tone, verification, etc.) via a UserPromptSubmit hook, slash commands, and an optional Haiku-powered auto-selector. It vendors the prompt-decorators engine with 140+ decorators across ~14 categories, allowing decorators to be applied inline with `::Name(params)` syntax, configured persistently, or selected automatically based on prompt content.

Groundwork is a comprehensive skills library for Claude Code containing 41 skills, 18 agents, and 5 hooks that consolidate proven techniques for planning, design, test-driven development, debugging, and collaboration. It integrates with bash and Node.js to enable workflows spanning from requirements gathering through implementation, code review, and quality verification.

Vitals scans a codebase to identify high-risk files by analyzing churn, complexity, and coupling, then uses Claude to diagnose root causes and recommend fixes ranked by ROI. It runs locally with no dependencies or API keys, silently tracking AI-generated edits via PostToolUse hooks to reveal automation patterns over time.

This plugin provides 13 skills for coding agents to query data and build semantic models through the Honeydew MCP, enabling natural-language questions about metrics, entities, and warehouse data. It integrates with multiple coding agents including Claude Code, Codex, and GitHub Copilot CLI to help users explore semantic layers, create business concepts, and analyze anomalies.

Automated security vulnerability scanner applying OWASP Top 10, CWE Top 25, and CVSS scoring frameworks to any codebase, with deep PHP/TYPO3 analysis via 80+ checkpoints and PreToolUse warnings for risky operations. Provides standards compliance guidance, secure coding patterns, and DevSecOps pipeline integration across multiple AI agent platforms.

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.

BetterCallClaude is a Swiss legal intelligence plugin that integrates BGE/ATF/DTF precedent research, case strategy, legal drafting, and citation verification for all 26 Swiss cantons with built-in Anwaltsgeheimnis privacy protection. It provides 27 commands across 21 agents for legal research, litigation strategy, document analysis, and multi-language legal translation (German, French, Italian, English).

This plugin automatically routes Snowflake-related prompts from Claude Code to Cortex Code for execution, detecting natural language queries about data and delegating them to Cortex's 55+ built-in skills. Non-Snowflake prompts remain in the current agent, with optional explicit routing via the `$cortex-run` command and configurable security envelopes (RO, RW, RESEARCH, DEPLOY) controlling what operations are allowed.

Compound V is a multi-model coding orchestrator for Claude Code that sizes feature requests, partitions them across isolated worktrees, and routes work to Claude, Codex, Cursor, and Antigravity workers based on complexity — planning with Opus, reviewing with parallel pre-flights (code archaeology, domain expertise, library validation), and gating writes through scope enforcement. It intercepts brainstorm-to-execution transitions with recon passes, maintains project-local memory over documentation, and supports epic mode for multi-feature builds with crash-resumable runs and adaptive tier-based routing.

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.

This Claude Code plugin teaches efficient CLI-based code and file search strategies using ripgrep, ast-grep, fd, rga, tokei, and scc, providing tool selection guidance and best practices for searching codebases of any size. It intercepts tool use to offer targeted pattern recipes and narrow search recommendations before executing searches.

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.

The Viv plugin makes Claude an expert in the Viv narrative language, maintaining a synced copy of the Viv codebase for efficient code navigation and lookup. It provides skills for setup, writing Viv code, debugging compiler/runtime errors, worldbuilding, and building integrations.

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.

tap enables multiple AI agents (Claude, Codex, Gemini) to coordinate on the same codebase using a file-based communication layer and shared workspace without custom integration code. It provides CLI commands to orchestrate parallel worktrees, manage bridge connections, and enable agent-to-agent handoffs through a comms directory structure inside the repo.

This plugin provides five core skills for ecosystem navigation, skill creation, research pattern analysis, session reflection, and plugin development, with a UserPromptSubmit hook that forces skill evaluation on user input. It integrates via a shell-based activation script to enable automated skill assessment workflows.

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.

DJ Claude is a live music engine that enables multiple Claude Code agents to jam together in real-time over HTTP, layering drums, bass, melody, and more with conductor mode and 22 presets. It requires no browser, API key, or external services—all music generation works out of the box via presets, vibes, or direct Strudel code.

Foreman keeps a project roadmap alongside your code and checks task context before handoffs, supporting Claude Code, Codex, and Antigravity. It tracks task status, blocks, and work awaiting acceptance while letting you verify plans against current code and review lessons from earlier work.

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.

Kindex is a persistent knowledge graph that indexes conversations and projects to provide AI coding agents like Claude Code, Cursor, and Gemini with continuous context across sessions. It captures relationships and constraints from intellectual work, exposing 50+ native tools through an MCP server to inject relevant context based on token budgets.

memory-kit provides persistent, managed memory for Claude agents as plain markdown files stored in your repository, with automatic injection at session start, pre-compaction guards, and lazy-loaded skills for memory auditing, session review, QA, and code synchronization. It operates through four hook events and includes four specialized agents (executor, recon, idea-validator, qa) plus ten skills—all governed by configurable size caps to keep memory focused and within budget.

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.

claude-english-buddy automatically corrects English grammar and typos in your prompts before Claude sees them, restoring a feedback loop that helps non-native speakers improve over time. It also translates non-English input, refines prompts with a :: prefix, and tracks your error patterns and improvement trajectory through daily and long-term analytics.

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.

This Claude Code plugin generates production-ready Scrapy spiders with web-poet page objects from plain-English prompts, automatically handling site exploration, schema discovery, code generation, and smoke testing. It can optionally deploy directly to Scrapy Cloud for scheduled runs and monitoring.

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.

Brewcode is a Claude Code authoring toolkit providing skill, agent, and rule creation with semantic code search, project conventions, E2E tests, and generated team-based code review. It maintains task context across Claude Code's compaction cycles through hooks and supplies 9 skills and 5 agents for managing development workflows, conventions, and specialized review processes.

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.

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.

marketing-cli is an agent-native CLI that installs 76 marketing skills, 9 agents, and persistent brand memory into Claude Code, enabling multi-session marketing workflows through a /cmo orchestrator and Studio dashboard. It chains external tools (Exa search, Firecrawl, FFmpeg, Playwright) with best-practices skills and maintains project-specific brand state across conversations.

Oh-my-obsidian connects Claude Code to an Obsidian vault to provide persistent project memory across sessions, auto-recording decisions and instantly recalling context through Markdown-backed search. The plugin includes guided setup, session-save automation, vault refactoring, and optional Git sync to keep your knowledge base organized and searchable.

mimirs is a persistent project memory system for AI coding agents that uses semantic search, AST-aware chunking, dependency graphs, and conversation history to help agents retrieve relevant code and context without burning tokens on irrelevant files. It runs entirely locally with bun and SQLite, requiring no API keys or external services, and has been benchmarked to reduce token usage by 76% while maintaining 90–98% search recall across codebases.

A Claude Code plugin that intercepts vague prompts via a hook, asks targeted clarifying questions based on detected tech stacks, and forges framework-aware structured prompts to avoid wasted API credits. It supports 30+ frameworks including Next.js, React Native, FastAPI, Tailwind, and Cloudflare Workers, with built-in pitfall rules and scope anchors for each stack.

cix is a semantic code search client for Claude Code that requires a self-hosted cix (CodeIndeX) server and provides slash commands, a bundled CLI, skills for single and cross-project workflows, and behavioral hooks that suggest cix over grep for indexed codebases. The plugin ships with eight slash commands, an experimental workspace skill for multi-repo tasks, and a sub-agent for parallel per-repo investigation with intelligent caching to minimize context overhead.

Gnosis MCP is a zero-config knowledge base server that indexes local documentation (Markdown, git history, crawled websites) and serves semantic+keyword hybrid search to Claude via MCP, typically reducing token consumption 5–10× per lookup. It stores data locally in SQLite by default or PostgreSQL at scale, with no cloud dependencies or API keys required.

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.

Mines every Claude Code session into a local SQLite database, capturing costs, tokens, tools, projects, errors, and full conversations for queryable usage history and pattern detection. All data stays local at ~/.claude/mine.db with no external transmission.

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.

This plugin indexes local documents (PDFs, Word docs, markdown, CSV, PowerPoint) into a vector database and performs semantic search with natural language queries in English or German, including hybrid keyword+vector search and source citations. It runs entirely offline with no API keys or cloud dependencies, using local embedding models and LanceDB for storage.

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.

Fleet Deck is a localhost control plane that displays all Claude Code sessions running on your machine on a single web board at http://127.0.0.1:4711, with live status derived from hook telemetry, conflict detection for concurrent file edits, and messaging between sessions. It provides features like permission-prompt handling, live terminal access via xterm.js, session revival from transcripts, and spawning of new agents, all designed as an optional accessory that never blocks Claude Code's terminal operation.

fuse-ai-pilot is a collection of specialized workflow agents including sniper (code quality), research-expert, explore-codebase, and websearch that implement the APEX methodology (Analyze → Plan → Execute → eXamine) with framework-specific reference auto-detection for Laravel, Next.js, React, and Swift. The plugin provides 9 agents across 17 skills organized by domain (code-quality, research, seo, exploration) and connects via PostToolUse/PreToolUse hooks while running shell commands.

fuse-cartographer generates indented markdown maps of the Claude Code plugin ecosystem to help agents navigate and discover available tools and skills. It provides ecosystem visualization through shell-executed commands triggered by session start and tool use events.

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.

A design director plugin that generates production-ready UI/UX for marketing websites, web apps, iOS, and Android—producing HTML/CSS directly for web targets and device-framed mockups plus handoff specs for mobile. Enforces a rigorous design method covering briefs, signature elements, anti-AI-slop principles, design systems with OKLCH tokens, motion profiles, UX copy, and a deterministic review gate aligned with WCAG 2.2.

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.

The fuse-laravel plugin is an expert Laravel 13 development assistant offering 23 specialized skills covering architecture, ORM, APIs, authentication, testing, queues, Livewire, templates, migrations, and billing with PHP 8.3+ and SOLID principles. It provides comprehensive documentation and PHP Attributes-first patterns, activated by keywords like Laravel, Eloquent, Blade, Livewire, and common development tasks.

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.

The fuse-php plugin provides an expert agent and six specialized skills for modern framework-agnostic PHP development (PHP 8.5/8.4), covering libraries, Symfony components, Slim apps, and CLI tools with PER Coding Style 3.0, PHPStan static analysis, and SOLID principles. It activates automatically when a composer.json is present without an artisan file, deliberately excluding Laravel projects which are handled by the fuse-laravel plugin.

fuse-react is a Claude Code plugin offering an expert React 19 developer agent with skills for modern React patterns (React 19 hooks, TanStack Router/Form), state management (Zustand, Jotai), component frameworks (shadcn/ui), testing (Vitest, Testing Library), and internationalization (react-i18next), all built around SOLID principles and modular architecture. It activates automatically when working with React projects and provides guidance on file-based routing, type-safe forms with Zod validation, and comprehensive testing practices.

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.

The fuse-security plugin detects and remediates security vulnerabilities including OWASP Top 10 issues, SAST scanning results, CVE risks, dependency problems, and exposed secrets. It integrates shell execution and tool hooks to audit code and dependencies in real-time.

fuse-seo provides technical SEO, schema markup, E-E-A-T validation, AI Overviews optimization, and local SEO capabilities as a local-first Claude Code plugin with framework awareness and zero third-party API dependencies. It covers sitemaps, hreflang, internal linking, content briefs, semantic clustering, and search experience optimization through 9 agents and 21 skills.

fuse-shadcn-ui is a Claude Code plugin that analyzes and assists with shadcn/ui components, Radix UI, Base UI detection, and component patterns through five specialized skills and two hooks for pre/post tool use. It supports theming configuration and migration scenarios for component library integration, requiring bun as an external dependency.

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.

Expert Swift 6 and SwiftUI development plugin covering all Apple platforms with specialized skills for architecture, concurrency, data persistence, and testing. The plugin includes an intelligent agent that activates relevant expertise when you mention iOS development, navigation patterns, async/await, performance optimization, or platform-specific features.

A Claude Code plugin providing expert guidance on Tailwind CSS v4.1 with CSS-native configuration, custom directives (@theme, @utility, @variant), and the faster Oxide engine. It includes 16 specialized skills covering layout, styling, utilities, responsive design, and new v4.1 features like OKLCH colors and container queries.

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.

Praxis is a reasoning methodology plugin that classifies problems, routes them to appropriate cognitive frameworks, and validates designs before execution by enforcing structured decision gates and checklists. It provides 18 specialized skills covering intent alignment, security reasoning, diagnostic analysis, code quality, architecture decisions, and strategic planning to ensure agents think deeply before taking action.

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.

Sage is a skills framework that guides AI agents through a structured process (UNDERSTAND → ENVISION → DELIVER → REFLECT) with 5 agent personas, 53 skills, and deterministic verification gates to ensure quality outcomes. It layers instructions smartly, detects knowledge gaps before implementation, and maintains session state across interruptions with persistent memory.

singularity-claude automatically creates, scores, repairs, and hardens Claude Code skills through recursive feedback loops that evolve skills based on execution performance. Skills progress through maturity stages (draft → tested → hardened) and are locked as production-grade once they achieve high scores across multiple runs.

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.

This Claude Code plugin enforces quality gates for 1C:Enterprise (BSL) development by blocking session completion until code-quality checks pass, analyzing changes across three axes (volume, code archetypes, complexity) to determine review depth. It produces human-readable findings and machine-readable evidence trails showing what was checked, what was skipped, and coverage across static analysis, development standards, SOLID/GRASP architecture, metadata XML integrity, and file hygiene.

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.

fable-baton routes routine development work from Fable 5 to tiered subagents (Opus, Sonnet, Haiku) based on task complexity, preserving Fable's tokens for judgment and orchestration. A SessionStart hook injects orchestration policy, a UserPromptSubmit reminder re-asserts delegation rules, and a PostToolUse counter enforces routing when consecutive inline tool calls exceed a threshold.

Karma is a Claude Code plugin providing 5 agent skills to find funding opportunities, create and manage projects, administer funding programs, and post milestones and updates—all on-chain via the Karma API with gasless transactions. Skills enable project setup, project management, funding program administration, and discovery of grants, hackathons, bounties, and other opportunities across the Karma ecosystem.

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.

Atelier Pipeline orchestrates eleven specialized AI agent personas (Eva, Robert, Sable, Sarah, Colby, Poirot, Agatha, Ellis, Distillator, Sherlock, Sentinel) to manage code quality, design validation, and testing across feature builds with multi-wave QA gates and blind review. It includes an optional persistent memory layer (Atelier Brain) backed by PostgreSQL and vector embeddings that retain architectural decisions, user corrections, and QA lessons across IDE sessions.

This Claude Code plugin provides WebSearch and WebFetch skills powered by DuckDuckGo as drop-in replacements for Claude Code's built-in tools, requiring no API keys or configuration. It uses Mozilla's Readability library to extract and convert web content to markdown, with support for domain filtering and retry logic.

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 streams background music across lofi, jazz, classical, ambient, electronic, and other genres directly into your coding sessions, with an AI DJ that learns your preferences and automatically selects music based on what you're working on. It integrates with your session lifecycle via shell hooks, supports multiple platforms (macOS, Linux, Windows, WSL2), and includes a focus timer with pomodoro sessions.

claude-music provides background music streaming with multiple genres (lofi, jazz, classical, ambient, electronic, synthwave, lounge, indie) directly within Claude Code sessions. An AI DJ (DJ Ken) automatically selects music based on coding activity and user preferences, with commands to control playback and customize the listening experience.

Galyarder Framework is an open-source agent operating system that routes high-level business intent through 45 specialized agents, 157 skills, and 25 commands to produce governed, verified execution across engineering, marketing, product, security, legal, and finance domains. It bridges strategy to implementation via structured intent intake, department routing, blueprinting, specialist execution, operational auditing, and artifact generation—with built-in review gates, audit trails, and human-directed control throughout.

H·AI·K·U is a Claude Code plugin that orchestrates AI workflows through structured stages with role-based "hats," completion criteria, and adversarial review gates, keeping state on disk to survive context resets. It provides 31 skills across multiple pre-built lifecycle templates (Studios) for engineering, go-to-market, and general-purpose work, with hooks for PreToolUse and PostToolUse events.

This Claude Code plugin connects iMessage to your Claude Code session via an MCP server powered by the Linq API, allowing two-way messaging where inbound texts are forwarded to Claude and Claude can reply, react, or edit messages. It includes built-in access control with pairing codes, allowlists, and configurable policies to manage who can message the assistant.

RTFM is a local, open-source retrieval layer that indexes code, documentation, PDFs, and other project files into a searchable SQLite database, exposing search and expansion capabilities via MCP for AI agents to find relevant context without grepping or hallucinating. It runs entirely offline with no API keys or cloud dependencies, offering full-text, semantic, and hybrid search through a Claude Code plugin or standalone MCP server.

SpecLock enforces project constraints written in CLAUDE.md, AGENTS.md, and .cursorrules files using semantic conflict detection, Git hooks, and MCP tools that intercept Claude Code writes, edits, and bash commands before execution. It operates in advisory mode by default and can be switched to strict blocking mode to prevent AI agents from violating explicit project rules through keyword matching, synonyms, and indirect action detection.

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.

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.

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.

idiolect provides 62 fully-specified human voice profiles and a deterministic AI-tell scanner to write, humanize, and audit social posts that read as distinct, genuine people verified by stylometry. The plugin includes a conformance checker, semantic auditor, and verify-revise loop that remove AI tells while maintaining individual voice characteristics across platforms like Reddit, HN, LinkedIn, Facebook, and X.

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.

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.

This Claude Code plugin integrates TwelveLabs' multimodal AI to index, search, and analyze videos directly within Claude Code, supporting natural language queries, image search, entity recognition, and both synchronous and asynchronous analysis modes. It provides 11 slash commands and 10 skills for managing video indexes, performing text/image searches, extracting summaries and key topics, creating embeddings, and organizing videos with customizable AI models (Marengo or Pegasus).

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.

Recall persists conversation context across Claude Code sessions and projects with full-text search, manual tagging, automatic keyword extraction, and cross-session highlight sharing via SQLite storage. It extends native Claude Code memory with queryable indices, tagging, and the ability to link and share findings between parallel sessions.

RepoPilot snapshots your repository before a Claude session starts and reviews all changes before the agent stops, blocking any session that skips tests, removes auth/error handling, or lets untrusted input reach dangerous sinks. The plugin runs deterministically and locally using the repopilot CLI via Git hooks and an MCP server, requiring no external API keys or services.

memo provides persistent, searchable memory for AI coding agents entirely on your machine using MLX embeddings on Apple Silicon or sentence-transformers on Linux, with markdown files as the source of truth and SQLite-vec for indexing. It reduces context overhead by 68% compared to full MCP surfaces while enabling time-machine queries, contradiction detection, and autonomous optimization via the "dream" pipeline.

This Claude Code plugin enforces mandatory AI workflows and performs intelligent codebase graph analysis by combining the superpowers methodology with AST-based code-review-graph analysis across Node.js, Flutter, and PHP projects. It provides graph-based tools for impact analysis, architectural visualization, and code quality review integrated into a TDD-driven workflow with planning, execution, and merge gates.

Yggdrasil provides a local-first, persistent memory system for AI coding agents that persists decisions, lessons, and project status across sessions, tools, and projects with zero external dependencies. It injects automatically at session start and allows agents to recall and share context from previous work without re-explanation.

Cortexes automatically records and indexes Claude Code sessions into a searchable markdown-based knowledge vault, using semantic search and BM25 indexing to retrieve past work and decisions. It integrates OpenAI embeddings for vector search (optional) and ChromaDB for local indexing, with session hooks to capture context at the start and end of each session.

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.