Code Review plugins for Claude Code

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.

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.

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

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.

Scientific Agent Skills is a library of 177 procedural skills for AI agents covering biology, chemistry, medicine, physics, engineering, Earth science, data analysis, and scientific communication, following the open Agent Skills standard for use with Cursor, Claude Code, Codex, and other compatible hosts. The skills provide curated guidance for specialized scientific libraries, databases, and workflows including bioinformatics, genomics, cheminformatics, proteomics, clinical decision support, and scientific visualization.

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.

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

This plugin recreates the deprecated Explanatory output style by injecting a SessionStart hook that instructs Claude to provide educational insights about implementation choices and codebase patterns throughout each session. The insights are formatted as highlighted blocks explaining specific decisions, conventions, and trade-offs in the code.

This official GitHub MCP server enables Claude Code to create issues, manage pull requests, review code, search repositories, and access GitHub's full API directly. Authentication requires a GitHub Personal Access Token for secure repository interaction.

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

This Claude Code plugin performs three-layer security review of code edits: pattern-based regex warnings on edits, LLM-powered diff review when Claude finishes a response, and agentic commit review that traces data flow to catch multi-file vulnerabilities like injection, XSS, SSRF, and hardcoded secrets. It integrates via hooks into the Claude Code editing workflow and supports customizable org-specific policies through markdown configuration files.

Serena is a semantic code analysis MCP server that provides intelligent code understanding, refactoring suggestions, and codebase navigation through language server protocol integration. It integrates with GitHub and requires only the uvx tool for setup.

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.

A collection of 9 verified Agent Skills for AI coding assistants covering Vercel deployment, React/Next.js performance optimization, React Native best practices, view transitions, web design audits, writing guidelines, and composition patterns. The skills extend agent capabilities with packaged instructions that trigger on specific coding tasks like "deploy my app," code reviews, and accessibility audits.

The Engineering plugin streamlines software engineering workflows—standups, code review, architecture decisions, incident response, and technical documentation—working standalone or integrated with tools like GitHub, Linear, Jira, Datadog, PagerDuty, and Slack. It provides six explicit slash commands and six domain skills that automatically assist with engineering tasks, from pull request reviews to production incident triage and postmortem writing.

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.

SkillSpector is a security scanner that detects vulnerabilities, malicious patterns, and security risks in AI agent skills before installation, using 71 vulnerability patterns across 17 categories and a two-stage analysis combining fast static checks with optional LLM semantic evaluation. It supports multiple input formats (Git repos, URLs, zip files, directories, single files) and generates terminal, JSON, Markdown, and SARIF reports with risk scoring and baseline suppression.

img2threejs converts reference images into procedural Three.js models via code generation, achieving animation-ready 3D reconstruction without photogrammetry or mesh extraction. The skill quality-gates outputs and optimizes for token efficiency, supporting object rebuilds, character likeness, and staged code generation workflows.

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.

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

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.

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

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

An official Flutter/Dart plugin that bundles 25 skills and an MCP server to teach AI agents domain expertise and best-practice workflows for building cross-platform applications from a single codebase. The skills cover testing, UI development, architecture, localization, routing, and API integration for mobile, web, desktop, and embedded projects.

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

This MCP server helps developers debug REST API failures by loading OpenAPI specs, ingesting HTTP logs, analyzing errors with root cause analysis, and generating reproducible test commands like cURL or fetch. The plugin includes a guided /debug-api command and an api-expert agent that provides severity assessment, fix suggestions, and support for common HTTP status codes.

Converts Figma designs and screenshots into production-ready React, Svelte, or Vue components with built-in accessibility features including ARIA labels, semantic HTML, and keyboard navigation. The plugin provides three MCP tools for parsing Figma exports, analyzing screenshot layouts, and generating fully accessible code components.

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

Project Health Auditor is an MCP Server plugin that analyzes local repositories for code health through four tools: listing files with glob patterns, calculating cyclomatic complexity and health scores, identifying frequently-changed files via git churn analysis, and mapping test coverage gaps. It combines complexity metrics, change frequency, and test coverage to provide multi-dimensional insights into codebase health without requiring external API keys.

pr-to-spec converts GitHub PRs and local code diffs into structured, agent-consumable specs with intent drift detection, using an MCP server for IDE integration and CLI tools for direct analysis. It lets developers declare change intent (goal, scope, risk ceiling), then checks for drift and produces exit codes and signals that autonomous agents can act on.

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.

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.

The Figma plugin integrates the Figma MCP server with 16 Agent Skills for common design workflows, enabling AI agents to read design context, generate code from frames, and write native Figma content directly to the canvas. It connects to Figma's design system data including variables, components, and layout information while supporting Code Connect integration and AI-powered image generation.

This plugin acts as a security reminder hook that warns developers about potential security vulnerabilities—including command injection, XSS, and unsafe code patterns—when they edit files. It uses a Python-based analysis triggered by PreToolUse events to flag risky code patterns before they're executed.

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 6 agents and 12 reusable skills for enhanced development workflows, including deep research, image generation (via Gemini and OpenAI), GitHub automation, brainstorming, and YouTube transcription. It requires npx and integrates with external APIs for image generation and research capabilities.

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.

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.

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.

A security audit skill that detects common vulnerabilities introduced by AI coding assistants in vibe-coded applications, including hardcoded secrets, broken database access controls (Supabase RLS, Firebase rules), missing auth validation, and insecure payment flows. The skill automatically activates when reviewing code that handles authentication, payments, databases, API keys, or user data, and organizes security checks by technology stack to avoid irrelevant rules.

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.

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

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

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.

This plugin adds a security reminder hook that triggers before code edits to warn about potential security vulnerabilities like command injection, XSS, and unsafe code patterns. It uses python3 to analyze code and flag risky practices in real time.

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

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

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

A Rust-built MCP server that validates, classifies, and governs AI-generated RDF/OWL ontologies through a three-layer architecture (Dynamics → Causal → Planner) with 70+ tools for ontology engineering, including SHACL validation, competency-question verification, alignment, and planning. The plugin ships as a single binary and includes an optional visual Studio desktop environment with AI chat, ontology tree navigation, and lineage tracking.

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.

This plugin provides 26 Vue, Nuxt, and NuxtHub skills for AI coding assistants, enabling auto-discovery and manual invocation of guidance for framework-specific tasks. Skills are automatically maintained and kept in sync with upstream documentation and ecosystem sources via GitHub Actions.

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.

MisakaNet is a git-backed failure memory for AI coding agents that stores and retrieves verified debugging lessons from previous failures, enabling agents to find pre-verified solutions rather than debugging from scratch. It provides search via an MCP server with evidence-graded lessons and an intake mechanism to turn new failures into shared knowledge.

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.

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

Audits CLAUDE.md and .claude/rules/*.md files for hidden or hostile directives (invisible Unicode, bidi overrides, command injection, secret exfiltration) and locks the session if violations are found. Enforcement spans three hooks: InstructionsLoaded detects, while UserPromptSubmit and PreToolUse prevent any execution until a human fixes or clears the poisoned file.

protect-tests is a PreToolUse hook that prevents agents from making test suites pass by deleting, renaming, or skip-disabling tests instead of fixing code. It detects and blocks removal patterns across pytest, unittest, jest/mocha/vitest, Go, JUnit/TestNG, NUnit/MSTest, RSpec, and Rust, with three configurable safety levels while always allowing new tests and legitimate test edits.

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.

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.

This plugin bundles 13 agentic skills for Qt C++ and QML development, including code review, documentation generation, testing, and UI design workflows, with a live Qt API documentation MCP server for contextual lookups. The skills combine deterministic linting with AI-powered deep analysis across memory safety, thread handling, performance, and QML binding correctness.

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.

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.

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

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

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.

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.

Context Engine is a standalone Agent Skill that teaches AI assistants to perform hybrid semantic/lexical search with neural reranking across codebases, navigate symbol graphs, and maintain persistent memory across sessions using 30+ MCP tools. It integrates with Claude Code, Cursor, Codex, Windsurf, and other AI assistants to enable code retrieval, cross-repo analysis, git history search, and structural pattern discovery.

UI Craft is a design engineering system for AI coding agents that applies opinionated craft rules and acceptance criteria to prevent low-quality UI output. It provides four rungs of capability—from default-better prompts through persistent design context to CI/review gates—plus a scoreable design critique using Nielsen heuristics and classic design laws.

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.

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.

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.

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.

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.

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.

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.

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.

Arcgentic is a harness engineering layer that wraps Claude Code and Codex with gated workflows: planning, development, self-audit, optional user testing, external audit, and closeout gates to enforce disciplined multi-round development. It prevents scope drift and lost context by turning ad-hoc prompting into a repeatable engineering process with role-based dispatch, stop states, and evidence collection.

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.

devteam transforms Claude Code into a full engineering organization with 14 specialized subagents (planner, fullstack-engineer, refactor-specialist, migration-engineer, frontend-designer, critic, vuln-verifier, debugger, db-expert, onboarder, tool-expert, web-researcher) and 20 automation hooks enforcing closure discipline, fact-driven reasoning, and exhaustiveness across the P7/P9/P10 methodology. It wires pre-commit secret scanning, MCP health tracking, cost monitoring, test running, and design quality checks to prevent bugs, security issues, and cost overruns before code reaches production.

This Claude Code plugin uses PreToolUse and PostToolUse hooks to detect and prevent common secrets leakage patterns such as environment variable echoing, secret file reads, tokens in URLs, and missing gitignore/permissions on sensitive files. It helps developers catch security misconfigurations before they happen by monitoring tool usage and enforcing safe patterns.

This Claude Code plugin provides 7 skills and an MCP server for building Medusa e-commerce applications, covering backend development (modules, workflows, API routes), admin UI customization (widgets, forms, tables), and storefront integration with React Query patterns. The plugin references public Medusa documentation and includes commands for database migrations and user management.

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

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

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

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

Superpowers Symfony is a skill library with 44 expert skills, 7 specialized agents, and 13 commands providing version-accurate Symfony expertise for coding agents, covering API Platform v4, Doctrine ORM 3, TDD with Pest & PHPUnit, Symfony Messenger, security/voters, and DDD/hexagonal architecture patterns. It integrates with Claude Code, Codex CLI, Grok Build, OpenCode, Cursor, Windsurf, GitHub Copilot, Gemini CLI, and aider through a SessionStart hook that runs runtime detection to adapt guidance to the target Symfony version and environment.

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.

Sloptrim is a local detector for AI-writing patterns that scores the first 262,144 characters of extracted prose from files (up to 512 KB plain text or 4 MB for supported archives) against 71 documented patterns, naming flagged spans for fixing before publication. It uses Python standard library only with no network or model calls, reads 20 file formats including .docx and .epub, and integrates into Claude Code via three hooks (PostToolUse, SessionStart, UserPromptSubmit).

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.

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

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.

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.

The xtquantai repository provides Agent Skills for QMT (迅投 quantitative trading platform), encapsulating domain knowledge like factor backtesting and signal generation into reusable skills installable via `npx skills add` across 70+ AI coding tools. The qmt-inner-backtest skill translates strategy descriptions, research PDFs, or screenshots into QMT daily-frequency cross-sectional factor backtesting scripts with Barra risk factor handling and future-function leak detection.

Deliberation delegates code review, architecture, debugging, and security analysis to GPT, Gemini, Grok, or 400+ OpenRouter models through MCP, with seven specialized agents that debate findings until consensus and optionally implement changes. Only Gemini can write code; GPT, Grok, and OpenRouter provide advisory-only second opinions via commands like /ask-all, /consensus, and model-specific ask commands.

This plugin provides secure access to Miro boards through Claude, enabling AI to read board context and create diagrams via three specialized skills for code explanation, review, and specification extraction. The plugin connects to the Miro MCP server and requires OAuth configuration with no external API keys.

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

This Claude Code plugin enables an autonomous review loop where Claude and code collaborate with adversarial pushback to plan features or audit code interactively in a single window. It provides 6 commands and a stop hook for managing the review cycle.

CodeDNA extends Claude Code with an in-source AI communication protocol that embeds structured annotations (exports, used_by, rules, agent logs) directly in source files across 9 languages and 7 template engines. Four commands (/codedna:init, /codedna:check, /codedna:manifest, /codedna:impact) and four automatic hooks provide architectural context, dependency tracking, annotation enforcement, and inter-agent communication without requiring external service calls.

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.

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

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

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

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.

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.

This Agent Skill provides comprehensive guidance for building and integrating Manifest DEX on Solana using the Manifest SDK, covering market reads, order placement, and account setup patterns. It enables developers to implement reverse and global order types and integrate DEX functionality into frontend applications.

This Agent Skill provides a complete guide for interacting with Marginfi, Solana's decentralized lending protocol, covering account creation, deposits, borrows, repayments, withdrawals, flash loans, and leveraged positions using the @mrgnlabs/marginfi-client-v2 SDK. It enables developers to automate lending, borrowing, and advanced trading strategies on the Solana blockchain.

This standalone Agent Skill provides integrations for building perpetual futures trading systems on Solana using the Phoenix exchange and Rise SDK. It covers TypeScript (@ellipsis-labs/rise), Rust (phoenix-rise), market data APIs, trader state management, transaction building, and risk-aware trading bot patterns.

Ranger Finance SDK enables building perpetual futures trading applications on Solana by aggregating liquidity across multiple perp protocols including Drift, Flash, Adrena, and Jupiter. It provides smart order routing, position management, and AI agent integration capabilities for decentralized derivatives trading.

This standalone Agent Skill provides a comprehensive guide for building AI agents that interact with the Solana blockchain using SendAI's Solana Agent Kit, covering 60+ actions and integration with LangChain/Vercel AI. It enables autonomous agent patterns and includes MCP server setup instructions for developers building Solana-based AI applications.

The vulnhunter skill detects security vulnerabilities and dangerous patterns in code by identifying sharp edges, footgun configurations, and finding vulnerability variants across codebases. It combines vulnerability detection with systematic variant analysis to help developers locate and remediate security issues.

This standalone Agent Skill provides deep architectural context building for security audits using Trail of Bits methodology. Use it when conducting security reviews, understanding codebases, mapping trust boundaries, or preparing for vulnerability analysis.

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.

Autoform helps formalize mathematical papers and research notes into Lean 4 proofs by planning work from source documents, writing formalized code, and reviewing progress with integrated Lean LSP and REPL tools. The plugin provides seven skills that guide users through setup, roadmap creation, formalization, and review workflows entirely within Claude Code or Codex.

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

A collection of 14 skills for AI coding agents working with Apollo GraphQL tools and technologies, covering Apollo Client, Apollo Server, GraphQL operations, schema design, Rover CLI, Apollo Connectors, and more. Skills are installable via Skills CLI, Claude Code plugin, or GitHub CLI, and integrate with the Apollo MCP Server for connecting agents with GraphQL APIs.

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.

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.

GitHits is a code context layer that runs as an MCP server to connect AI coding agents to indexed open-source evidence across the full software development lifecycle. Agents can search package and repository source, read files and documentation, inspect package health, compare dependency upgrades, and find source-cited examples from real open-source projects.

Buddy is a persistent AI coding companion plugin that provides real-time feedback via a PostToolUse hook, maintaining character stats, XP progression, and personality across 21 species stored in local SQLite. It works with Claude Code, Codex, Gemini, Copilot, Cursor, OpenClaw, and other MCP-capable clients to catch reasoning loops and react contextually to your work.

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.

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.

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.

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.

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.

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.

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.

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.

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

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 skill enables Claude Code to manage code snippets in a self-hosted ByteStash instance through a command-line API, supporting creation, searching, updating, deletion, and sharing of single or multi-file snippets. It provides organization through categories and tags, with advanced features like expiring share links, protected shares, and bulk operations via jq integration.

This Agent Skill systematically addresses GitHub pull request review comments by fetching threads via the GitHub CLI, creating tracked tasks for each comment, and applying fixes with mandatory resolution verification to ensure no comments are missed. It blocks PR completion if any review threads remain unresolved, providing end-to-end accountability from comment to explicit resolution.

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.

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.

The codeact skill enables code generation and execution using Python tools when explicitly activated by the user. It provides a standalone capability for writing and running Python scripts within an Agent environment.

Monocle is a terminal UI that enables real-time code review of AI agent output with line-level comments and structured feedback submission. The agent skill set integrates with Monocle to allow agents to send plans for review and retrieve reviewer feedback through a blocking or non-blocking workflow.

Claude Universe provides five integrated systems—Navigate, Diagnose, Shield, Survey, and Timewarp—that enable systematic code analysis for PR readiness, test authoring, security review, architecture tracing, and code evolution detection. It combines 6 MCP servers for deterministic pattern matching and dependency analysis with 20 Claude-guided commands and 6 autonomous agents that work across any language.

This stop hook evaluates Claude's final answer against the turn's tool output using TypeSafe's Jev decision model to detect unsupported claims, then sends Claude back to re-check if hallucinations are detected. It integrates with the grounded-ai Python library to provide hallucination detection and fact-checking with optional fallback to LLM judges like Claude, GPT, or local models.

A collection of self-contained exercises teaching Claude Code best practices through hands-on "before vs. after" prompting patterns, using real hydrology concepts like streamflow analysis and USGS gauge data. Three bundled skills provide domain knowledge (hydro-context), standardized reporting (flow-report), and test automation (run-tests) for hydrological research workflows.

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.

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.

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.

CodeScene Code Health analysis plugin for Claude Code provides AI-friendly tools to review, refactor, and safeguard code quality through Code Health scores, hotspot detection, and ownership routing. It integrates via MCP with support for OAuth, personal access tokens, and on-prem instances, offering both standalone analysis and cloud/on-prem project-level insights.

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.

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.

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.

claude-mem-lite is a persistent memory system for Claude Code that automatically captures coding decisions, bugfixes, and context across sessions using MCP hooks and stores them in a single SQLite database with FTS5 full-text search. It achieves 7-10× fewer LLM calls and ~600× lower estimated cost than the original claude-mem by batching episodes and using a smaller model, with zero external services.

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.

EquilateralAgents is a collection of 22 self-learning AI agents that scan code for security issues, quality problems, and compliance violations, then harvest discovered patterns into YAML-based standards to prevent those mistakes from happening again. The system creates a feedback loop where agent findings are converted into institutional knowledge that gets automatically injected into future sessions across Claude Code, Cursor, Codex, and Windsurf.

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

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.

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

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.

The mako-ai plugin teaches Claude Code when to use Mako's MCP tools for project intelligence tasks like code search, diagnostics, and RLS audits instead of basic grep-walking. It packages 8 category-scoped skills (mako-guide, mako-discovery, mako-trace, mako-neighborhoods, mako-graph, mako-database, mako-code-intel, mako-workflow) that integrate with an MCP server running the agentmako package.

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

Graph-It-Live is an MCP server and skills bundle that performs dependency, call-graph, impact, and architecture analysis on codebases through an integrated agent plugin. It provides four skills (graph-it-live, onboarding-express, dead-code-hunter, and pr-review) and works across Claude Code, GitHub Copilot CLI, VS Code, Cursor, and Codex.

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.

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.

Makoto is a verification plugin that audits Claude Code agent behavior against logged records, blocking fabricated tool checks while allowing sixteen legitimate advisory self-checks. It enforces integrity across two-tier catalogs of 17 pre-checks and 30 stop gates, all calibrated to zero false positives.

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.

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.

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.

Kimi is a Claude Code and Codex plugin that integrates the Kimi Code CLI to provide independent code review, explanation, and editing capabilities from a different model family within your existing session. It delegates read-only review and write-capable rescue tasks locally through the kimi-code CLI while enforcing safety rules via a PreToolUse hook.

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.

svelte-grab runs an MCP server inside your Svelte 5 dev app to give coding agents precise visibility into page elements, components, source locations, and accessibility—with locators that work with Playwright and Chrome DevTools MCPs. Agents can inspect what's rendered, identify component files and line numbers, check props and state, and verify changes look correct after edits.

A comprehensive SAPUI5/OpenUI5 plugin providing 8 best-practices skills, MCP tools for project scaffolding, API documentation, linting, and development/testing guidelines covering accessibility, integration cards, OPA5 testing, QUnit patterns, MDC/smart controls, and tables. Requires npx and includes an MCP server for direct agent integration.

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

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

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.

promptscout enriches Claude Code prompts with local codebase context by analyzing your prompt with a local LLM (Qwen 3 4B) and discovering relevant files, code sections, and git history using ripgrep and git. The plugin hooks into your prompt submission flow, appending discovered context before Claude sees it—no API keys or cloud required.

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.

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.

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.

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.

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.

This standalone Agent Skill repo provides two Dart and Flutter SDK changelog skills that equip AI coding agents with version-specific language features, APIs, widget deprecations, and migration guides spanning Dart 1.0–3.13+ and Flutter 1.0–3.47+. The skills include fast lookup matrices for minimum SDK compatibility, macros, experimental features, Material 3 migrations, and structured runbooks for rescuing legacy codebases.

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

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

cxpak is a Claude Code plugin that provides structured codebase context through auto-invoked skills, on-demand commands, and MCP tools spanning 43 languages via tree-sitter. It analyzes project health, dependency graphs, change impact, and security surface in real-time with deterministic output across LSP, HTTP, and MCP interfaces.

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.

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

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.

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

This Claude Code plugin provides 6 skills and 2 MCP servers for building Solana applications with Helius infrastructure, including tools for blockchain queries, DFlow trading, Phantom wallet integration, Jupiter DeFi, and SVM architecture. It includes live blockchain tools, expert coding patterns, autonomous account signup, and reference documentation for all major Helius products and integrations.

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.

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

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.

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.

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.

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.

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.

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

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.

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

This Agent Skill provides a two-gate scanner that detects AI texture ("slop") in prose while verifying quote accuracy against source documents using pure Python with no external dependencies. It flags banned phrases, narrative clichés, and over-correction in Gate 2 (taste), then validates every quoted or attributed line against primary sources in Gate 1 (source fidelity).

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.

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.

repo-security-review is a standalone Claude Code skill that performs comprehensive multi-phase security audits of code repositories, including secret scanning, architecture analysis, dependency vulnerability checks, OWASP code review, and dynamic verification with optional proof-of-concept generation. It supports full-repository scans, pull-request diffs, multi-service analysis, and vendor tool audits, with findings validated through isolated subagents before generating a single markdown report.

This plugin delegates coding tasks to OpenAI Codex CLI, allowing Claude to run them synchronously or in the background while tracking their output. It integrates an MCP server and a skill to provide access to Codex functionality directly from Claude.

This Claude Code plugin enables delegating coding tasks to Cursor agents by spawning sub-agents that run synchronously or in the background. It includes an MCP server that allows tracking agent output and coordinating work across multiple Cursor instances.

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.

breaking-coding-chaos (BCC) is a human-in-the-loop dual-loop control-plane skill suite for coding agents that keeps progress and technical detail under control while implementing concrete ideas. It provides four Agent Skills that work across all agentic coding runtimes (Claude Code, Codex, Grok, Cursor, OpenCode, Hermes, OpenClaw) to maintain durable context, enforce design alignment before code, and produce minimal correct diffs—especially powerful for multi-week work, high-stakes bug fixes, and resume-after-context-loss scenarios.

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.

A suite of 59 Claude Code hooks that detect and block 30 LLM dark patterns (sycophancy, paternalism, false-success, permission-loops, fake recall, fake citations, and others) at the closeout boundary using deterministic textual enforcement. Operates entirely out-of-band with no model in the verdict path, supporting multiple locales and destructive-command surface hardening through extensible rule packs.

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.

rag-rat is a local repository intelligence plugin that bundles an MCP server with semantic search, symbol navigation, and impact-surface analysis, plus hooks that automatically install a version-matched binary on first use across Claude, Codex, Cursor, and VS Code. The plugin provides git/GitHub integration with a source-anchored memory graph and requires only Node.js, handling all environment setup transparently.

This Claude Code plugin scans your codebase for AI API calls and generates a migration plan showing exactly where and how to replace expensive LLM calls with ScaleDown's task-specific SLMs (up to 95% cheaper), then optimizes your prompts against your own sample data with a reproducible evaluation. It supports OpenAI, Anthropic, LangChain, LlamaIndex, Cohere, Vercel AI SDK and more, with no codebase data ever sent to ScaleDown servers.

This standalone Agent Skill teaches Claude Code and compatible agents to build Flutter forms using the advanced_forms package, with support for typed field controllers, composable validators, async validation, cross-field rules, and subforms. Install it with `dart run skills@ get` or manually copy the SKILL.md file to enable idiomatically generated form code.

A standalone agent skill pack for AI-assisted Aptos blockchain development, offering 16 skills spanning Move smart contract generation, testing, security auditing, gas optimization, and TypeScript SDK integration. Skills activate automatically in Claude Code, Cursor, and GitHub Copilot based on developer intent, enabling the full dApp lifecycle from project scaffolding to deployment.

nexus-agents intelligently orchestrates multiple AI coding tools (Claude, Gemini, Codex) by routing tasks to the best model, validating outputs through multi-model consensus voting, and learning from outcomes to improve routing over time. It provides a full development pipeline with 30 MCP tools for agent management, research, memory, codebase intelligence, and quality gates including security scanning.

This Claude Code plugin enables AI-to-AI collaboration by orchestrating multi-provider code reviews and debates across Codex, Grok, Antigravity, Ollama, and Gemini through a unified skill corpus deployed to Claude Code, Cursor Agent, and Pi. It bundles MCP server configurations and provides adapters for host-specific workflows including code pairing, verification, and cross-LLM brainstorming.

pulser is a SKILL.md linter that diagnoses Claude Code skills against 8 rules derived from Anthropic's published principles, classifies skill types, generates prescriptions, and runs eval tests for regressions. It runs conversationally in Claude Code or from the terminal, with auto-fix capabilities and a hospital-style TUI monitor.

claude-evolve is a Claude Code plugin that applies the ShinkaEvolve evolutionary algorithm using Claude's built-in model tiers (opus, sonnet, haiku) at different thinking-effort levels to autonomously optimize code toward user-defined fitness functions. It requires only the claude CLI and Python 3.10+, maintaining multi-island populations, detecting novelty via AST analysis, and learning which model-effort combinations produce the best improvements via UCB1 bandits.

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

This plugin detects low-value "AI slop" comments in code diffs and steers clean comment generation by extracting comments deterministically, judging them against quality criteria, and acting on each with keep/trim/rewrite verdicts. It operates in two scopes—diff-based (changes introduced) or repo-wide—and applies edits to a review branch while preserving required documentation comments and factual content.

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

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

This Claude Code plugin enforces Go language coding standards and best practices while preventing accidental modifications to generated Go files marked with the standard "Code generated" header. It provides guidance on Go conventions, table-style tests, and language features through a PreToolUse hook that blocks edits to auto-generated code.

The lets plugin provides development workflow management with session initialization, code review capabilities, and task tracking through 26 commands organized across 15 agents and 16 skills. It integrates with the lets external tool and executes shell commands while responding to PreCompact and SessionStart hook events.

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

This plugin injects planning guidelines and context into Claude Code sessions, enforcing a 10k-character plan size limit and gating plan resubmissions that are unchanged or overly similar to prior versions. It also provides a skill to review implementation drift against the approved plan by diffing the code against the plan using a clean-context agent.

This plugin provides four skills for managing pull requests: creating PRs with structured formatting, updating PR bodies to reflect changes, following up on review feedback to find resolutions and draft replies, and monitoring CI to auto-fix trivial failures like linting and formatting issues. It supports git worktrees and runs shell commands via bun, with a hook that validates PR content before creation or edit.

This plugin provides code review workflows for Claude Code, offering both model-invocable skills to review working diffs and PR comments on GitHub/GitLab, plus background agents that dispatch incoming review requests. It includes follow-up tracking, human review request integration, and multi-angle analysis powered by Sonnet.

roast-my-design-system scans your codebase to measure design system health with a deterministic score, identifying color duplicates, spacing inconsistencies, and inline styles against real benchmarks from 112+ public repos. It generates a shareable HTML report and prioritized fix recommendations tailored to your tech stack (MUI, Mantine, Chakra UI, Ant Design, Tailwind, or custom systems).

Roast-my-design-system scans your repository to audit design system health, generating a deterministic score backed by detailed findings on colors, spacing, component duplication, and inline styles. It benchmarks your repo against 119 public repositories and 10 reputable design systems, then produces a shareable HTML report with ranked fix recommendations.

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

Semgrep Guardian scans agent-generated code for security vulnerabilities using Semgrep's static analysis engine integrated as a Claude Code plugin. It monitors tool usage before and after execution, checking generated code at session start, end, and stop events to catch security issues early.

This plugin detects newly added type ignores and lint suppressions across multiple languages (TypeScript, Python, Go, Rust, Ruby, etc.), then automatically fixes the underlying type errors or replaces unfixable ignores with explanatory TODO comments. It runs automatically via a PostToolUse hook when Claude adds an ignore, and can also be invoked directly with the `/fix` skill for codebase-wide cleanup.

This Claude Code plugin enforces writing style and detects AI-generated language patterns in human-facing prose like PR descriptions, comments, and documentation through hooks that check for vague vocabulary, promotional language, and templated constructions. It provides skills for analyzing writing tropes, rewriting text, scanning for violations, and conducting multi-agent document reviews using configurable wordlists and pattern detection.

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

A general-purpose Java coding plugin with 14 skills, 2 agents for architecture guidance, and tools for applying Java 8+ coding standards. It integrates with Maven and uses shell-based analysis to understand Java project structure and enforce best practices.

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

A Claude Code plugin that inserts a human review gate after every turn that edits files, adding one-line doc comments to touched classes and functions, summarizing changes in 60–120 words, and prompting the developer to Approve or Undo. The plugin uses Python hooks (PreToolUse, PostToolUse, Stop) to intercept file modifications, flag security and migration risks, and restore snapshots on undo without requiring git.

CodeAlive context engine provides semantic code search and AI-powered codebase Q&A, enabling agents to understand entire codebases beyond open files and trace cross-service dependencies. It includes authentication hooks, a code exploration subagent, and multiple search modes (lexical, semantic, deep cross-cutting), working standalone or alongside the CodeAlive MCP server.

Graperoot builds a dual call graph and dependency graph of your codebase to recommend the most relevant files and symbols before Claude starts exploring, reducing token usage and improving accuracy. It includes an MCP server (mcp-graph-server) that provides graph scanning and retrieval tools, plus a skill that teaches Claude the retrieval protocol.

This plugin auto-installs the mistral-mcp MCP server and exposes 11 curated skills that integrate Mistral AI capabilities—including chat, vision, Voxtral audio transcription, Codestral code generation, and French-language workflows—directly into Claude Code. The underlying server provides 25 Mistral tools, 3 resources, and 6 prompts for advanced use cases like code review, meeting transcription, and invoice handling.

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

This Claude Code plugin integrates Aikido Security to scan code for vulnerabilities, secrets, and infrastructure-as-code issues via the Aikido MCP server. It retrieves and displays security findings directly from your Aikido feed within the Claude Code editor.

This Claude Code plugin automatically validates that tool outputs match the claims Claude makes about them, catching discrepancies like misquoted code and incorrect file references. It operates as a post-tool-use hook that inspects the results of Claude's tool calls to ensure accuracy and consistency.

This Claude Code plugin intercepts tool calls via a PreToolUse hook to validate assumptions before execution, using an external check-assumptions.sh script to assess whether preconditions are met. It helps prevent tool misuse by catching invalid assumptions at runtime.

This Claude Code plugin installs a hook that intercepts Claude responses at the Stop event to scan for speculative language, unverified claims, and hallucination patterns before delivery. It performs real-time content screening to help mitigate unreliable or fabricated outputs without requiring external APIs or services.

This plugin provides hook examples and reference implementation demonstrating how to build Claude Code plugins with PreToolUse, SessionStart, and UserPromptSubmit lifecycle events. It includes four hooks with shell-based validation and utility scripts for timestamp addition and context loading.

MAMA (Memory-Augmented MCP Assistant) lets you save development decisions and checkpoints in a local SQLite database, then retrieves them automatically across Claude Code sessions using hooks and MCP. The plugin tracks decisions with reasoning, provides search capabilities, and injects relevant context when reading files or compacting conversations.

Refine is a heavyweight multi-agent workflow plugin that cross-examines repository issues across multiple perspectives to reach consensus, then applies only the highest-ROI fixes to code and documentation. It uses a PreToolUse hook to intercept and guide tool execution, with shell capabilities for executing fixes directly.

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

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

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

agy-plugin-cc delegates code review and investigation tasks to Gemini CLI or Antigravity CLI (agy) as a cross-model engine, exposing Claude Code-native commands for pragmatic review, adversarial challenge, and background job handling. The plugin spawns the engine binary you install locally and operates no intermediary service—data flows directly from your machine to Google's servers via your chosen CLI.

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

claude-watchdog automatically runs a critical post-mortem analysis at the end of each Claude Code session, comparing what was requested against what actually changed in the repository using git diff and delivering a structured review of goals, efficiency, quality, compliance, and recommendations. All analysis happens in-session using existing Claude Code credentials with no external API calls or additional keys required.

A curated set of 76 Claude Code skills (markdown instruction files) covering combinatorial optimization end-to-end: exact methods like MILP, branch-and-bound, and decomposition; 22 metaheuristic families; problem encodings and operators; 17 classic problem classes; and research workflows for Python with Gurobi, OR-Tools CP-SAT, and HiGHS. Installed via Claude Code marketplace, the skills.sh CLI, or manually into ~/.claude/skills/.

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

story-flow is an agentic development workflow plugin that coordinates planning, analysis, implementation, and QA automation through 5 agents and 5 skills to manage software development tasks end-to-end. It uses 4 MCP servers and npm tooling to orchestrate the development lifecycle without requiring external API keys.

Bullpen is a Claude Code plugin that creates a team of 64 named AI specialists, each with distinct expertise (UI design, backend development, security, database architecture, etc.) and opinionated defaults that you invoke via commands or natural language. Each specialist maintains per-project memory in a local JSON file that learns from your actual development patterns and syncs across clones of your repository.

Delegates self-contained coding and research tasks to the Cursor CLI (cursor-agent) from Claude Code, routing them through Cursor's subscription quota instead of Claude's, with support for single tasks or parallel fleets managed by Claude. Long-running tasks execute in ~4-minute resumable legs to survive network interruptions, and includes a Persian web copywriting pipeline with dependency-free linting to enforce ZWNJ, punctuation, and readability standards.

Ken enforces a systems-discipline philosophy inspired by Ken Thompson's Unix design approach, guiding AI agents through a structured loop of thinking first, stealing proven ideas, building bottom-up, brute-forcing until measured, and rewriting over patching. It provides 6 skills, lifecycle hooks, and shell-based commands to track code health metrics like rewrites, reuse, root-cause fixes, and dependency vouching.

attune-ai adds persistent memory and receipt-verified workflows to Claude Code, featuring 28 auto-triggering skills for code review, testing, security audits, documentation, and spec-driven development without requiring explicit commands. The plugin uses quality gates, pre-run contract previews, and independent probe verification to ensure work is completed reliably, with decision records that persist across sessions.

A multi-agent development workflow skill that orchestrates Claude Code Agent Teams through five modes (plan, dev, full, auto, bugfix) with collaborative roles like Architect, Developer, Code-Tester, QA-Tester, and Reviewer working through quality gates and approval workflows. Teammates debate directly within teams, execute wave-based task dependencies, track session state across branches, and enrich pull requests with agent notes.

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

Co-Dialectic automatically sharpens prompts, detects hallucinations, and routes work to cost-effective models across every Claude Code conversation. It includes 11 reusable skills like prompt rewriting, stakes inference, cross-family verification, and session continuity management.

context-os builds a lightweight static graph of your repo to inject ranked file:line candidates at the start of Claude Code sessions, letting Claude skip the first-turn "grep hunt" and reducing token overhead by 40.9% in A/B testing. A PreToolUse hook also intercepts full-file reads and serves just the file outline (symbols + line ranges), avoiding re-sending 800-line reads on every subsequent turn.

A standalone Agent Skill that orchestrates multiple AI consultants (Gemini 3.8 Flash, Codex, GLM-5.3, Kimi K3) and Claude subagents for consensus-driven code reviews, plan validation, and architectural decisions with weighted synthesis and false positive filtering. Invoked via `/council` commands with specialized review modes (security, architecture, bugs, quality, adversarial, etc.) and includes a secret scanning gate using gitleaks before contacting external consultants.

This standalone Agent Skill repo provides 10 skills covering code review, testing, deployment, and quality checks through babysit, dlc, git-ops, perf, pr-check, pr-validity, quality, security, test, and update-review-checklist capabilities. The skills are designed to integrate into development workflows without requiring external API keys or tool dependencies.

jules-review is a standalone Agent Skill that reviews pull requests created by Jules (Google's AI coding agent) using an AI council workflow and posts structured GitHub PR reviews with inline comments. It auto-detects Jules PRs, intelligently selects between quick and full review modes based on diff size, and lets you confirm the review severity before posting to GitHub.

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

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

Rugproof is a Claude Code plugin that transforms your editor into a full-stack smart contract security auditor, providing vulnerability detection, exploit PoCs, mainnet-fork simulation, and invariant generation across Solidity and Vyper on all major EVM chains. It includes 45 slash commands, 23 specialist agents, 45 auto-invoked vulnerability skills, and 13 MCP servers for comprehensive static analysis, testing, and post-deploy monitoring.

This Claude Code plugin installs a security reminder hook that triggers before tool usage to warn developers about potential security vulnerabilities like command injection, XSS, and unsafe code patterns. It uses Python 3 to analyze code and flag risky practices during file editing workflows.

skillhub is a collection of 20 standalone Agent Skills that augment Claude Code with memory, research capabilities, and structured coding workflows—including research skills (/pulse, /verdict, /factcheck, /jobfit, /scout), daily-work skills (/daybrief, /learn, /tune), and a coding loop for shipping (/feature, /bugfix, /done, /refactor, /map, /autopilot). All skills are keyless and run on Claude Code's native web and sub-agent tools plus free public endpoints, with no external API keys or signups required.

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

Project Scaffolder generates a complete project structure from a brief, including a persistent 12-page wiki, domain-specific skills, execution docs with model routing, and a gated task pipeline with QA and user testing to maintain code consistency across sessions. The plugin uses 19 slash commands, hooks to prevent destructive operations, and a skill lifecycle system that grows expertise over time.

pstack is a workflow orchestration plugin that provides 17 rigorous agents and 61 composable skills to help you write higher-quality code with less manual effort. It enables parallelizable agent workflows designed for speed and code quality, with a SessionStart hook that initializes your development environment.

SAP Superpowers is a Claude Code plugin that transforms Claude into a senior SAP consultant with 61 skills, 25 agents, and 8 slash commands covering the entire SAP lifecycle—from consulting and development to delivery and hypercare. It provides industry-aware and country-localized guidance with zero telemetry, zero API keys, and enterprise-grade data protection through markdown-based hooks.

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

This Claude Code plugin provides six skills for scaffolding, configuring, and integrating Airwallex payment and billing APIs into projects, covering hosted payment pages, embedded card elements, subscription billing, and KYC onboarding flows. It connects to the Airwallex Developer MCP connector to access current API documentation and sandbox environments for code generation and verification.

Cadence is a plan/execute/verify loop for Claude Code that uses adversarial review (Claude subagents or external models like OpenAI, Gemini, DeepSeek) at every gate to validate plans and diffs before code is written. State lives in `.planning/` files on disk rather than in conversation, enabling aggressive context clearing and lean token usage across sessions.

The claude-crap plugin enforces test-driven development by wrapping Write/Edit/Bash tool calls with PreToolUse and PostToolUse gates that verify code quality metrics (CRAP index, Technical Debt Ratio, tree-sitter AST) and SARIF 2.1.0 reports before allowing code writes. It prevents functional code from being written until adequate test coverage exists, backed by 4 skills, 1 MCP server, and hook handlers for SessionStart, PostToolUse, PreToolUse, Stop, and SubagentStop events.

jev-mcp is an MCP server exposing TypeSafe Jev, a System One model that returns typed answers with calibrated probability distributions for classification, scoring, yes/no checks, batched questions, and multi-item triage with server-side file reads. The plugin registers as a single Claude Code installation and requires a TypeSafe API key from console.typesafe.ai to operate the judgment tools.

Razor is a Claude Code plugin that intercepts code generation to prompt reconsideration of dependencies, file growth, and unnecessary additions before implementation. It runs targeted checks via hooks at key points in the development workflow and provides an audit of unused dependencies without automatic removal.

skraft turns refined user stories into researched, designed, tested, and reviewed code changes through a deterministic four-phase engineering pipeline (RESEARCH→DESIGN→DISTILL→DELIVER) with specialized agents and adversarial reviewers for each phase. Runtime hooks enforce phase order, artifacts, verdicts, and commits while supporting outside-in TDD, Clean Architecture, BDD, and safe brownfield modernization workflows.

A starter kit providing code review and teaching agents alongside project setup, testing, and explanation commands, plus a file-formatting hook for Claude edits. It includes three executable commands, two agents, a skill template, and a PostToolUse hook that formats files after Claude modifies them.

claudestory enables cross-session context persistence for AI coding projects by maintaining a `.story/` directory that tracks tickets, issues, roadmap, handovers, and notes across Claude Code sessions. The plugin provides 30 MCP tools, CLI commands, and autonomous work execution features so each session builds on the previous one without re-explanation.

Tellonce records corrections you make to your Claude Code agent and optionally enforces them via local SQLite rules, preventing the same mistakes from recurring—safe observation by default with opt-in hard enforcement. It works across Claude Code, Codex, and GitHub Copilot CLI, learning from your feedback and reducing preference violations from 100% to 2.0% on out-of-distribution tasks according to its research evaluation.

The trail Claude Code plugin auto-wires the trail MCP server to enable runtime log capture and querying, bundling a `/trail:debug-with-trail` skill that guides agents through a structured debugging workflow of capturing, querying, and cleaning up instrumentation logs. The plugin requires the trail binary to be installed separately on your PATH and auto-triggers when asking about debugging, errors, or runtime behavior.

A Claude Code plugin that automates the full development cycle from spec through plan, implement, review, and clean phases using markdown commands and bash hooks. It provides 12 agents, 31 skills, and 14 hooks to manage task decomposition, CI gates, code review with multiple perspectives, and artifact cleanup with zero external runtime dependencies.

Agent Skills is a collection of 21 production-grade engineering workflows and quality gates that guide AI coding agents through the full software development lifecycle—from spec definition through deployment. The plugin activates relevant skills automatically based on context or through seven slash commands (/spec, /plan, /build, /test, /review, /code-simplify, /ship), encoding senior engineering practices into consistent, repeatable processes.

This Claude Code plugin extends development workflows with ClickHouse best practice skills for schema design, query optimization, and data ingestion, plus an MCP server that connects Claude to ClickHouse Cloud for schema inspection and read-only SQL queries. The plugin provides automated guidance aligned with ClickHouse best practices whenever you work with ClickHouse.

cli-dispatch is a multi-backend delegation hub that routes tasks to worker CLI backends including DeepSeek-powered Claude Code, Antigravity, OpenAI Codex, OpenCode, and GitHub Copilot. It provides deterministic execution with session tracking, read-only mode sandboxing, MCP isolation, and optional auto-install of missing workers.

This Claude Code plugin implements a persistent-memory and runtime-discipline layer that remembers corrections, grounds edits in verified facts, and transforms fixes into reusable instincts through the Mulahazah engine, built on 7 Laws of AI Agent Discipline. It ships with 28 bundled skills, 14 hooks, 4 agents (code-reviewer, security-auditor, test-engineer), 29 commands, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.

A comprehensive Claude Code plugin offering 54 skills, 6 autonomous agents, and intelligent hooks for code review, architecture, security, DevOps, and engineering leadership across 11+ programming languages. Features declarative skill activation, model routing with cost optimization, and continuous learning to assist CTOs and Staff Engineers in shipping production software.

This Claude Code plugin enforces design-first coding by rendering plans and code reviews as annotated call graphs (Design Graphs) in a stack-agnostic notation before implementation begins. It provides commands to toggle Design Thinking mode, generate and review call graphs, and map the graph protocol onto language-specific idioms like error handling and resource management.

Flash Agents is a Claude Code plugin that delegates bounded coding tasks to DeepSeek V4.1 Flash workers running in disposable repository copies, returning patches for Claude to review and apply. Claude retains architectural control and final review while workers spend their own tokens on implementation, reading, and writing work.

Frank is a Claude Code plugin that enforces evidence-based agent replies by requiring concrete verdicts with proof and verification receipts after code edits. It uses local hooks to observe PostToolUse and session events, comparing final agent messages against a ledger of verification commands to prevent unsupported claims.

Godmode is a local, tamper-evident evidence ledger that verifies what coding agents actually executed by maintaining a hash-chained record of commands, changes, and refusals rather than trusting agent claims. It enforces gates at runtime through hooks on tool use, session events, and user input to prevent irreversible operations and grade agent "done" claims against recorded evidence instead of agent word.

The graft-pack plugin provides context-aware code navigation through a graft skill and two hooks that automatically inject file:line locators in response to "where is X" queries and display dependency blast-radius notes after edits. It requires the graft CLI tool to be installed on the system and integrates with Core's /impact command for dependency analysis.

Guild turns a single coding session into a self-evolving team of 15 specialist agents organized across engineering, content, and commercial domains, coordinated through a v2 lifecycle (init·ideate·plan·build·qa·ops) with structured decision capture and shadow-mode gating. The plugin provides 110 skills, 3 machinery agents, 22 commands, and 21 hooks to manage brainstorming, team composition, specialist planning, context assembly, dispatch, review, and continuous self-improvement within your project.

This Claude Code plugin provides 13 skills for exploring, analyzing, and developing analytics code within the Holistics Development environment. It integrates with shell execution and includes a post-tool-use hook to support analytics development workflows.

This Claude Code plugin integrates Ix Memory to turn Claude into a graph-reasoning engineering agent with cognitive skills for understanding, investigation, impact analysis, planning, debugging, architecture auditing, and documentation synthesis. It hooks into Claude's tool use and file editing to maintain a persistent code knowledge graph and minimize token usage through structured memory queries.

jig is a Claude Code workflow layer that enforces spec-driven development with built-in review gates, memory continuity, and deterministic hooks to prevent common AI-assisted coding pitfalls. It scaffolds a structured workflow from idea through implementation and independent review, bundling 20 skills and 19 hook-based guardrails to keep projects lean and reviewable across sessions.

lsp-pack provides symbol-level code navigation through the Serena LSP MCP server, enabling semantic search, definitions, and references across your codebase. It requires the serena binary to be installed separately (via uv) and complements text search for more precise code exploration.

PagerDuty Claude Code plugins bring operational intelligence into your development workflow with pre-commit risk assessment using incident history and change correlation, plus the ability to create and manage PagerDuty skills for AI agents. The plugin bundle includes 2 commands and an MCP server that connects to PagerDuty's operational data.

This unified code review plugin for jj repositories uses a two-phase pipeline with generalist-first reviewers that scale to change size, plus emergent specialist agents triggered by repeated review patterns. It provides structured findings via shell commands with options for progress tracking, GitHub PR posting, and JSON output.

This plugin runs Microsoft's PowerShell Editor Services and PSScriptAnalyzer after every AI edit, returning diagnostics directly into Claude's context so mistakes are caught and corrected in the same turn. It manages the PowerShell toolchain automatically, provides proof that analysis actually ran via a doctor command, and works identically in CI, air-gapped, and live editing environments.

This Claude Code plugin connects to the Shopify Dev MCP server, providing access to Shopify's developer docs, API schemas, and code generation for GraphQL, Liquid, and UI extensions. It enables developers to search Shopify documentation, generate and validate code, and build Shopify apps directly from their editor.

Superpowers is a software development methodology plugin that equips Claude Code with 14 composable skills for test-driven development, debugging, and collaborative agent workflows. It automates a structured process from spec gathering through subagent-driven implementation with autonomous task execution and review cycles.

Taskplane coordinates multi-stage software delivery by connecting design, planning, implementation, and verification through agents and skills that can run independently or in sequence. It keeps requirements, dependencies, and review findings linked throughout the task lifecycle, with dashboard visibility and optional autonomous execution within user-defined boundaries.

Token-guard is a Claude Code plugin that monitors and controls token consumption through hooks that warn on large file reads (100KB+), limit unique file reads per session, estimate token budgets, and cap subagent spawns. The plugin uses extracted operational data from 800+ hours of autonomous operation to provide consumption guardrails.

zetetic-gates enforces quality gates on Claude Code and Codex through pre- and post-tool hooks that check source craftsmanship, prose standards, secret exposure, and test validity before commits and pushes. It validates that new tests can fail against base code, prevents credential leaks, and applies structural/prose checks using project-specific configuration profiles.

A Claude Code plugin that enforces epistemically rigorous reasoning through 97 sourced patterns from historical figures, routed automatically to 15 problem-shaped skills with commit-time enforcement gates. The system prevents unsourced claims, magic numbers, and untraceable decisions by blocking commits until cited evidence or measurements are provided, making uncertainty and provenance explicit across the agent reasoning lifecycle.

This plugin provides 36 atomic capabilities organized across 9 cognitive layers for building reliable AI agents with typed contracts, safety checkpoints, and grounded reasoning. It enforces structural reliability through pre- and post-tool-use hooks that manage checkpoints, audit logging, and provenance tracking to prevent hallucinations and enable rollback on failures.

The atk plugin provides 16 skills, 1 agent, and 25 commands for AI/LLM development patterns including RAG, embeddings, LangGraph, prompt engineering, and multi-agent orchestration. It offers AI-native development utilities with no external API dependencies, running entirely through local shell execution.

claude-flow is an open-source framework that equips Claude Code with structured project knowledge and autonomous execution capabilities through 4-layer project configuration (Constitution → Rules → Skills → Commands) and an 8-layer autonomous engine. This standalone Agent Skill provides 4 built-in skills (tdd, verification, brainstorming, and one unnamed skill) for test-driven development, pre-completion verification, and design exploration workflows.

A comprehensive Convex plugin for Claude Code that bundles backend design skills, a live-scaffolding quickstart tool, code-writing and code-review subagents, and an MCP server for deployment introspection. It steers Claude toward Convex idioms and primitives for building reactive, type-safe backends with schema, real-time updates, authentication, file storage, and scheduled jobs.

dtk is a DevOps toolkit plugin with 15 specialized skills, 2 agents, and 12 commands for infrastructure and backend development on AWS, Terraform, Kubernetes, and serverless platforms. It includes pre-commit hook setup, observability, cost optimization, and code review capabilities for Python Lambda, PostgreSQL, and REST APIs.

A comprehensive engineering toolkit for Claude Code with 27 skills, 5 agents, and 21 commands covering quality gates, architecture decisions, testing strategies, automated research, and workflow orchestration. It supports autonomous code review, Sentry investigation, codebase analysis, and experimentation loops with shell command execution capabilities.

Forge is a Claude Code plugin that runs an autonomous build loop where a supervisor and adversarial critic continuously inspect the running product with real tools (browser, test runners, scanners) and only approve when all roles agree the result is world-class. The builder, supervisor, and critic are all Claude Code operating without additional API keys or LLM calls, with verification powered by 139 deterministic tools and zero npm dependencies.

This Claude Code plugin integrates Google's Gemini CLI to perform code reviews, whole-codebase analysis, and task delegation with Gemini's 1M token context window. It provides commands like /gemini:review, /gemini:analyze, and /gemini:consult, backed by a Node.js companion that manages background jobs and integrates with Claude Code's session lifecycle.

The Lovable Claude Code plugin bundles the official Lovable MCP server to create, edit, deploy, and manage AI-powered full-stack apps directly from Claude Code using natural language commands. It integrates project workflows including building, iterating, deploying, and managing cloud databases with built-in safeguards for credit and publish operations.

marc is a Claude Code plugin that organizes a seven-agent team (tech lead, engineer, SRE, design, security, review, and research specialists) to collaborate on code reviews and development tasks through an IRC-styled interface. The team coordinates through the tech lead agent and uses 3 skills and 7 hooks to manage workflow across multiple repositories.

A native-first Claude Code and Codex workflow plugin providing 16 task-level skills covering orchestration, research, implementation, debugging, verification, safe effects, and independent review, plus hooks for destructive-command protection and skill-loading reminders. The plugin compiles Go hooks locally, includes a concise output style, and contains no external API dependencies or prebuilt binaries.

sonmat is a Claude Code verification plugin that injects structured doubt and reasoning checks (guard/inspect/witness/punch/devil/scribe) into agent workflows and subagents. It uses markdown discipline blocks, automated hooks at session start, and persistence layers to surface verification reasoning and prevent silent failures.

Zuvo is a multi-agent skill ecosystem providing 58 specialized skills and 26 agents for structured software development workflows across Claude Code, Codex, Cursor, Antigravity, and Kimi Code. It includes quality gates, knowledge persistence, session recovery, and pipeline automation from brainstorming through code execution to deployment and canary releases.

agentic-skills provides flagship capabilities for AI coding agents including a workbench-builder that deploys disposable localhost development environments with Bun.serve, SQLite, React 19, and Astryx for real-time human-agent collaboration over SSE. The plugin includes seven MCP servers and integrates with multiple search and knowledge APIs (Brave, Context7, Exa, Tavily, You.com) to power agent reasoning and research workflows.

An autonomous software engineering pipeline that uses Claude to write code changes through structured state machines (lean/standard/rigorous), with cost attribution and audit trails written into your repo. The plugin provides `/work` and `/receipt` commands to generate pull requests and render shareable verification logs of all AI decisions.

This Claude Code plugin delegates coding tasks to Google's Antigravity (agy) CLI, enabling full rescue, resume, background execution, review, and status tracking directly from the Claude Code environment. It provides 12 commands, 1 agent, and 3 skills with session lifecycle hooks (SessionStart, SessionEnd, Stop) and shell execution capabilities.

ai-architect-mcp-codebase is a Rust MCP server that indexes any codebase (11 languages) into a LadybugDB property graph with full AST, tracking imports, references, and execution flows while exposing 26 tools for agents to query symbol relationships and impact analysis. It runs entirely on-machine, read-only, and answers structural questions like "who calls this" and "what breaks if I change it" by querying the real code graph rather than grepping.

This MCP server and Claude Code plugin orchestrates multi-agent AI workflows through structured markdown documents with automatic context injection and pre-built workflow templates for development, testing, planning, and decision-making tasks. It provides 13 commands and 2 agents to manage specifications, coordinate task assignments, and maintain impartial code reviews across sequential or ad-hoc project work.

Coordinator is a core orchestration plugin that addresses six failure modes in AI-assisted development through session lifecycle management, named code reviewers, research pipelines, and 26 workflow skills spanning planning, review, synthesis, and architecture auditing. It enforces quality gates from specification through execution via structured agent routing, write-ahead status protocols, and persistent decision capture.

A PM-native Claude Code plugin that enforces structured software delivery through session lifecycle management, named code reviewers, and 41+ workflow skills that route work from product intent through scoped plans to ship decisions. It treats Claude as an engineering manager handling implementation while the PM retains authority over scope, tradeoffs, and ship/no-ship calls via a decision architecture backed by Python-enforced doctrine and 87 hook scripts across nine lifecycle events.

devcycle turns a one-line feature or bug description into a verified, reviewed implementation on its own git branch through a guided pipeline: scoped interview, wave-based planning, parallel subagent execution, cross-model review, and on-device UI verification via claude-in-chrome. It closes the loop on pull requests by reading review comments and reconciling them, while benchmarking its own performance to improve the pipeline over time.

docpin grounds Claude in version-matched documentation by detecting installed library versions from your project's lockfiles and fetching docs pinned to those exact versions across npm, PyPI, crates.io, and Go. It automatically triggers before Claude writes code importing third-party libraries and provides explicit commands to pull docs for specific libraries or topics.

DotnetPilot is a Claude Code plugin that provides 29 commands, 14 specialized agents, and Roslyn-powered semantic analysis to catch common .NET mistakes like missing DI registrations, unsafe EF Core migrations, and architecture violations in real time. It includes convention-aware scaffolders, clean-architecture enforcement, DI verification, and project lifecycle management with 16 skill packs backed by an MCP server.

Flutter Slipstream enables AI coding agents to inspect and interact with running Flutter apps in real time via screenshots, widget-tree inspection, and user input simulation, while also providing accurate Dart package API summaries directly from the local pub cache. It addresses agent blindness in app development by offering runtime visibility and training-cutoff-proof package information.

Green Keeper automatically fixes failing tests and type errors with minimal changes while enforcing a "no fake-green" rule that prevents weakening tests, silencing errors, or cheating with type-widening. It provides `/green` and `/cover` commands plus a Stop hook that blocks you from leaving red that your turn introduced, running entirely locally with zero external dependencies.

Teaches Claude to integrate and debug the Hyper Solutions anti-bot API (Akamai, Incapsula, DataDome, Kasada) across Go, Python, and JavaScript/TypeScript SDKs, with a bundled skill and two MCP servers for request inspection and HAR analysis. The powhttp MCP captures live traffic via proxy to analyze header order and TLS fingerprints, while the har-analyzer MCP runs the fingerprint rule set against exported HAR files.

A markdown-only collection of 16 agent skills for Claude Code, Codex, Gemini CLI, and other coding CLIs — covering architecture (vertical-slice, C4 models), code quality (low-complexity, testing strategy), review workflows (dual code/Codex debate, PR explanations, comprehension quizzes), and specialized guidance (STE simplified English, Argentine ELI5 explanations, agent context auditing). No runtime dependencies or build steps.

Objection enforces a mandatory adversarial review process for pull requests, where an accuser model identifies issues in the diff, a defender refutes with specific file:line evidence, and your session judges the verdict before a local hook and CI gate allow PR creation. It integrates with Claude Code, Cursor, GitHub Copilot, and other AI agents without requiring hosted services or bot accounts.

OPM is a Claude Code plugin that enforces a test-first, spec-driven engineering workflow by splitting work across fresh-context subagents, holding quality gates with mandatory code review, and capturing decisions to a persistent ledger that survives session resets. It includes skills for design brainstorming, architecture planning, test-driven execution, verification, and turning specs into narrated explainer videos.

OptiKit is a CLI toolkit for Flutter developers that provides 28 MCP tools for building, versioning, and deploying apps across iOS and Android with combo commands and smart automation. The Claude Code plugin integrates OptiKit's capabilities so Claude can understand your project structure and execute build, version management, and module scaffolding commands directly via MCP.

PhanesLight is a multi-agent orchestration system for Claude Code that generates a project-specific agent roster, enforces code discipline through pre/post-tool hooks, and maintains durable project memory across sessions using a single bootstrap prompt file. The plugin ships language-independent scripts and templates that integrate into any repository without external dependencies beyond Node.

py-pit provides 16 opinionated skills for AI coding agents (Pi and Claude Code) to scaffold and develop modern Python APIs using FastAPI, SQLAlchemy, Alembic, and uv. Skills activate automatically when the agent detects relevant intents like API initialization, ORM design, testing, migrations, and configuration management.

quiz-me gates code changes by requiring developers to pass an interactive quiz where Claude tests their understanding of the root cause and fix before implementing changes. The plugin uses hooks and a skill to investigate issues, generate quiz questions, and validate developer knowledge before proceeding.

This plugin captures LLVM bitcode from any build and exposes it for querying through rllvm-query's MCP server. It provides 3 skills to interact with compiled code analysis and bitcode inspection.

Superfast is an enterprise-grade Claude Code plugin that combines test-driven development, debugging, and collaboration patterns with a FastMemory engine for handling massive codebases beyond native context windows. It automatically maps repositories into a deterministic cognitive graph, guides systematic design through Socratic brainstorming, and orchestrates autonomous subagent-driven development with iterative code review and planning.

Transmute Framework is a Claude Code plugin that autonomously transforms a business plan into a fully deployed product through a 25-stage pipeline called Plan Casting, where AI agent teams handle everything from tech stack selection to feature implementation, security auditing, and production deployment. The framework executes 23 automated stages plus 2 manual decision points, generating specifications, scaffolding projects, implementing features in priority order, and producing deployment-ready code and documentation.

unity-devtools attaches to a running Unity Mono development build via the Mono Soft Debugger protocol and exposes live type reflection, C# expression evaluation, ECS entity/component reads and writes, and screen capture through an MCP server and a unity-driving skill. The plugin requires no code injection and works generically with any dev-Mono Unity game exposing the debugger endpoint.

AI Architect MCP Spec is a TypeScript MCP server that deterministically validates feature descriptions into verified 9-file PRDs by cross-checking symbols against a live codebase graph and ensuring every acceptance criterion traces back to its requirement. It runs on your machine with multi-judge consensus and Bayesian reliability calibration, catching hallucinated specs before code generation consumes them.

Tagout is a gate-verified issue-to-pull-request lifecycle manager for coding agents that enforces safety checks at destructive steps using named gates that refuse operations and report who locked them. It includes optional tagout-migrate for .NET legacy application upgrades with a seven-phase migration pipeline, roseline gates, and MCP servers for Roslyn-aware code analysis.

apple-hig ships a complete on-disk reference of Apple's Human Interface Guidelines (iOS, iPadOS, macOS, watchOS, tvOS, visionOS) and automatically designs and reviews UIs to match them, with a router skill that loads only the files relevant to the current task. It includes verified design tokens, typography, color palettes, layout rules, and accessibility minimums from the current Liquid Glass/Golden Gate generation, all without fetching Apple at runtime.

The claude-code-kit plugin orchestrates 33 specialized agents and 16 skills to automate the full development lifecycle—from task planning and implementation through code review, security scanning, and testing. It includes built-in hooks for secret protection and code formatting, and integrates with external tools like ruff and MCP servers for research and API development.

devloop is a TypeScript dev-loop runtime that provides controlled PR/MR workflows for AI coding agents, supporting Git operations, component-aware linting/testing, and automatic platform detection for GitHub and GitLab. It enforces execution-level guards, manages concurrent worktrees, and maintains state via a shared Board to prevent context drift and accidental rule violations.

The Doom Design System plugin equips AI agents with comprehensive knowledge of a neubrutalist React component library, including component APIs, design tokens, theming, and coding standards. It includes 4 agents, 3 commands, 1 skill, and 1 hook that intercept pre-tool-use events to guide component selection and implementation.

This skill repo provides agent-agnostic tools for EPLAN Electric P8 scripting (C#, API, Remote Client) and EPLAN EEC Pro development (typicals, formula language, configuration, generation pipelines), with a smart router that loads the right skill based on your task. It includes three remote MCP servers for querying official EPLAN P8 2026/2027 and EEC Pro 2026 documentation, plus reference guides distilled from production code and live testing covering version-specific quirks, threading issues, and generation workflows.

harnish is an autonomous implementation engine that breaks down PRDs into atomic tasks, executes them iteratively with failure-driven guardrails, and accumulates patterns and experience across sessions. It integrates with sibling plugins galmuri (for decision-forcing and post-implementation inspection) and drafti (for PRD generation from planning documents).

This Claude Code plugin fetches GitHub pull requests and generates a rich, interactive HTML review UI that groups diffs into logical chunks with AI reasoning, syntax highlighting, and contextual annotations—then posts your line comments back to GitHub. The diff shown is always byte-for-byte from GitHub; Claude only groups, orders, highlights, and annotates without rewriting code.

This plugin turns coding tasks into an interactive learning game where Claude solves problems in a scratch worktree while you type, learn, or review the code line-by-line with contextual explanations and grading. Sessions run entirely in your local project folder with automatic cleanup, requiring only Node.js 20+ and a browser.

magic-codex orchestrates parallel Codex workers within Claude Code using git worktree isolation and resumable sessions to manage concurrent code analysis and modifications. The plugin enables dual-model PR review with 3 coordinated agents and 9 specialized commands integrated across 2 MCP servers.

Delegates coding tasks (implementation and tests) to a local pi agent while Claude writes the task specification and validates results, with enforced discipline modes to prevent Claude from editing production code directly. Integrates via MCP tools (pi_dispatch, pi_status, pi_steer, pi_abort, pi_result, pi_transcript, pi_stats) and hooks that intercept Write/Edit operations in strict or soft modes.

planwright is a Claude Code plugin that automates spec-driven development by executing signed specifications through an agentic pipeline, handling task advancement, draft PR creation, and convergence while preserving human control over sign-off and merge decisions. It scales from single-spec autopilot to multi-spec fleet mode, operating as a software factory with bounded iteration, verification loops, and guardrails built entirely on Claude Code primitives.

secondmate is a Claude Code plugin that implements cross-model code review by spawning a maker agent to write code and a different model (like gpt-terra) to review it in read-only mode, gating merges until the checker passes, automated safety checks succeed, and you approve. The plugin manages planning, supervision, scope guards, durable decisions across restarts, and optional reasoning model analysis without external API keys.

senior-dev orchestrates disciplined Claude Code coding sessions by classifying tasks, enforcing a mandatory chain of installed skills, and gating commits on code review, verification, and documentation. It finishes with a zero-leftovers hygiene sweep and includes read-only Codex review passes as phase gates.

The Sentry plugin for Claude Code provides 8 skills and an MCP server for debugging workflows, including SDK setup wizards, production issue debugging, code review with Sentry context, and monitoring configuration. It connects to the hosted Sentry MCP server at mcp.sentry.dev for querying Sentry environments.

This plugin audits Claude Code community skills for 26 security attack patterns including prompt injection, data exfiltration, credential access, reverse shells, and privilege escalation using 3 parallel scanning agents and runtime defense hooks. It includes manifest inspection, Semgrep custom rules, CLI scanning tool, and AWS IAM policy templates for least-privilege environments.

This plugin integrates Sourcegraph's MCP server into Claude Code, enabling code search, navigation, Deep Search, and Code Finder capabilities directly within the IDE. It installs a `searching-sourcegraph` skill with pre-built workflows for feature implementation, debugging, code review, and understanding codebases.

Supervisor is a 27-agent quality-control layer for Claude Code that researches externally verifiable claims, delegates work to specialized experts, runs tests, and enforces a final release gate before delivery. It includes independent reviewers, anti-hallucination verification, adversarial red-teaming, and coding/frontend specialists to catch outdated docs, fabricated APIs, broken code, and unsupported claims before they reach users.

Tagout orchestrates a gate-verified GitHub issue-to-pull-request workflow with skills for creating, implementing, and merging code changes using shell scripts as verification guards. It includes specialized tooling for auto-dev gates, backlog triage, and legacy .NET application migration with no external API dependencies.

tagout-migrate is a seven-phase pipeline that automates migration of legacy .NET applications to verified production using RoselineMCP and Roslyn code analysis. It includes the roseline Read gate and roseline + ADR MCP servers, integrating dnx and .NET 10 SDK tooling with shell-based orchestration.

workkit is a Claude Code plugin that transforms GitHub Issues into an automated SDLC pipeline, with an agent crew that specs, builds, reviews, and tests each issue from inbox to shipment. The system uses GitHub labels for workflow states, 5 delegated agents, 9 skills, and 28 hooks to enforce quality gates at each stage without manual intervention.

This plugin provides two skills for building token swaps and DeFi integrations: the 0x-api skill for developers with an API key, and the 0x-agentic-gateway skill for autonomous agents paying per-request via wallet-based micropayments. It includes an MCP server that gives AI agents live access to 0x documentation and API references.

This plugin enforces a 7-step workflow discipline for AI-assisted development through 24 skills grounded in Covey's 8 Habits, from requirements gathering through monitoring, and includes cross-verification checklists to prevent common shipping mistakes. It runs as a thin harness with on-demand markdown skills that guide spec-first development across any AI coding tool (Claude Code, Cursor, Codex, Windsurf, Aider).

This Claude Code plugin provides a verification gate for AI-generated work by anchoring goals into versioned run files and spawning independent validators to prove correctness before allowing closure. It operates via slash commands (`/a:run` and `/a:setup`) with a bundled CLI tool that runs over Bash, requiring no external APIs or MCP servers.

a11y-fixer scans HTML and JSX code for accessibility violations and issues. It operates as a self-hosted skill with no external API dependencies, using local tools to perform static analysis.

This plugin audits and fixes accessibility (WCAG 2.2) and internationalization issues across React, Vue, Svelte, Angular, and HTML, applying cross-element ARIA remediation, keyboard-focus corrections, color-contrast rewrites, hardcoded-string extraction with stable ICU MessageFormat keys, and RTL-ready CSS transformations. It works entirely offline on local files as reviewable diffs, never machine-translates or fabricates content, and cites the specific WCAG success criteria behind every change.

A Claude Code plugin that plans work before editing and routes each step to the most cost-effective model (haiku, sonnet, or opus) with four-way verification. It includes 10 tiered subagents, 9 authoring skills, local MCP tools, and gated fail-open hooks that run shell guards at key lifecycle stages.

AD Guardrails automatically injects security, architecture, performance, and delegation rules into Claude Code at session start, before each code write, and before git push, using 4 specialized agents and 12 skills to enforce OWASP compliance and scalability for 10,000+ users without repeating instructions. The plugin reinforces rules through hooks, automated audits (gitleaks, semgrep, trivy), and a global ~/.claude/CLAUDE.md file that persists across all projects and sessions.

Agent Runway injects architectural context into subagents before code execution and validates file writes against module boundaries and project conventions. When violations are detected, the agent self-corrects automatically without human intervention.

A Claude Code plugin that provides skills, subagents, and hooks for test-first development workflows with automated routing between model tiers based on task complexity and failure recovery. It includes session handoff tracking, code review integration, and test-proof verification to ensure changes don't introduce regressions.

This plugin generates Android/Kotlin projects with Jetpack using an MCP server and a skill. It requires npx to function but does not depend on external paid services.

Detects and fixes OpenAPI/GraphQL spec-vs-code drift across 10+ frameworks, hardens endpoints with request validation, RFC 9457 error envelopes, and idempotency handling, and audits job queues for at-least-once reliability—all statically without running servers or sending requests. Grounded in real file:line evidence and diff-aware, it reconciles contracts continuously in the editor by updating either the spec or the code to match the authoritative side.

A comprehensive full-stack Next.js development plugin that provides scaffolding, database integration, API design, authentication, and automated quality gates across the development lifecycle. It includes 17 specialized skills for Next.js, TypeScript, Prisma/database design, API patterns, testing, and security scanning with hooks that enforce code quality pre- and post-edit.

ashlr is an open-source Claude Code plugin with 40 MCP tools and 36 commands that reduce token usage by up to 65% through hybrid LLM summarization (Anthropic Haiku 4.5 default with optional ONNX offline processing) and PreToolUse redirect hooks. It includes GitHub OAuth sign-in, automatic genome generation from public repos, per-session token accounting, and supports multiple hosts (Claude Code, Codex, Cline, Claude Desktop, Cursor, Goose).

Bearpaws enforces adaptive engineering discipline for Claude Code by automatically escalating risk-based proof requirements—pinned tests, failing-first approach, and independent code review—for high-impact changes while keeping routine work lightweight. It includes 15 reusable skills for TDD, debugging, planning, and parallel execution, plus a Stop hook that blocks incomplete elevated-risk replies until a risk receipt and review are present.

Brana is an AI development system that provides 68 reusable skills, 14 agents, and 40 hooks integrated with Claude Code to enable systematic software engineering workflows. It exposes shell execution and hook events across the development lifecycle—from session start through tool use, compaction, and agent coordination—to automate common development patterns.

Carrick is a Claude Code plugin that indexes TypeScript codebases across service and repository boundaries, automatically adding file routes, calls, and cross-service type mismatches to each editing session via hooks. It pairs with the Carrick MCP server and CLI to enable agents to search functions by intent rather than name while tracking contract violations across repos.

Claude Code + Cursor Agent Orchestration (CursorACP) is an agent orchestration system where Claude Code handles design, review, and deployment decisions while Cursor Agent executes code implementation and file editing via a Python bridge with Phase 0-8 pipeline. This configuration dramatically reduces Opus context usage (up to 78%) by separating high-level reasoning from low-level code generation, leveraging Cursor's LSP integration and parallel execution for faster, more cost-effective development.

claude-damn is a composable skill library and opinionated harness for Claude Code that ships 61 skills built from modifier families (super/duper/cat/tdd), expert-review workflows, cost tracking, checkpoint lifecycle management, and a PreToolUse hook that guards against inline multiline scripts. It layers on top of the superpowers plugin and provides granular permission guards, CLAUDE.md project rules, and support for isolated git worktrees and parallel subagent execution.

A collection of 5 Polish-language agent skills for Claude Code including dev-browser (persistent browser automation for scraping and research), advisor-board (multi-agent debate framework), find-skills (skill discovery and installation), humanizer, and tribunal (adversarial code review with prosecutor, defender, and judge roles). All skills are open-source with no external API keys required, though some integrate with existing tools like dev-browser CLI and OpenAI Codex.

This Claude Code plugin integrates the CodeGraph CLI to maintain a live project code graph inside Claude sessions, syncing automatically after edits and git operations. It provides Claude with structural understanding of the codebase through one-line graph command prompts at session start.

Codebase Navigator helps developers bootstrap unfamiliar repositories, decode complex build systems (Make, Bazel, Gradle, Maven, npm, Nx, Turborepo, CMake, cargo, go), and localize changes by mapping code flows and dependencies. It provides four commands to set up dev environments, explain build targets, locate where changes belong, and trace request flows end-to-end with source-linked evidence.

The Codex plugin is a first-party local CLI tool that delegates code reviews, task management, resumable threads, and durable background jobs without external dependencies. It runs entirely on Node.js and integrates with session lifecycle via hooks.

This Claude Code plugin generates meaningful commit messages and enforces git safety by blocking force-push operations and preventing direct pushes to protected branches. It uses shell hooks to intercept git commands before execution and applies smart guardrails to the commit workflow.

Concise is a Claude Code plugin that intercepts verbose comments, oversized files, and padded PR/issue descriptions before they're written, offering pluggable em dash and AI writing pattern detection with presets for different teams. The agent reads denial reasons and rewrites flagged content in real time, preventing bloated output from reaching your working tree or GitHub.

ContextMatic provides coding assistants with deterministic, version-aware API context generated directly from OpenAPI definitions and SDKs, replacing outdated training data with current, executable code samples and recommended workflows. The plugin includes an MCP server and two skills that give agents access to curated context for 9+ supported APIs (Adyen, Google Maps, PayPal, Slack, Spotify, Tesla, Twilio, and others) across multiple languages.

This plugin provides an agentic loop foundation with deterministic safeguards including append-only logging, confidence thresholds (0.7/0.85), mandatory critic review, and a governance gate that flags but does not block undisciplined code edits. It includes two agents (echo and critic), a /start-project skill for PRD ingestion with drift detection, and hook-based control over tool usage and task execution.

This Claude Code plugin specializes Claude in C++26 idioms and standards (ISO/IEC 14882:2026) through an always-in-context skill, reference MCP server, and two-pass verification agent that biases generation toward modern features like reflection, contracts, and senders. It surfaces compiler lag separately from genuine bugs and scaffolds C++26-ready project configuration, keeping recommendations standards-first even when the local toolchain hasn't caught up.

A complete Domain-Driven Design workflow plugin with five composable skills: project initialization, roadmap generation, TDD-driven development, 8-dimension architecture audit, and automated batch execution. Skills orchestrate through a pipeline for analyzing projects, generating phased plans, implementing features with quality gates, and continuously auditing against DDD standards.

This plugin orchestrates implementation delivery by distributing tasks to developer agents, where each task is reviewed and committed before running plan verification and code review. It uses hooks and subagent-driven execution to manage the full workflow from plan approval through final validation.