Skip to content
/
Tier B A2 Mirror cmd+skill

Awesome Claude Code Plugins

ccplugins-awesome · ccplugins/awesome-claude-code-plugins · ★ 806 · last commit 2025-10-14

Primitive shape 122 total
Commands 116 Subagents 6
00

Summary

ccplugins/awesome-claude-code-plugins — Summary

Awesome Claude Code Plugins is a community-curated catalog and installable Claude Code plugin marketplace hosting 116 plugins across 13 category verticals — workflow orchestration, DevOps automation, business sales, code quality, data analytics, design/UX, development engineering, documentation, git workflow, marketing, project management, security/compliance, and growth.

Problem it solves: The official Claude Code plugin ecosystem lacks a searchable community marketplace; individual developers publish standalone plugins but there is no central discovery layer. This repo provides both the catalog (README-as-index) and the actual plugin code, each plugin installable via /plugin install directly into Claude Code.

Distinctive trait: Ships both an Awesome-list catalog and 116 deployable plugins in a single repo — each plugin follows the standard Claude Code plugin structure (.claude-plugin/, agents/, commands/ sub-directories). The 5 "Official Claude Code Plugins" section highlights first-party reference implementations (agent-sdk-dev, pr-review-toolkit, commit-commands, feature-dev, security-guidance).

Target audience: Claude Code developers looking for community-built agents, subagents, and commands to install; also a reference for plugin authors wanting to see structural patterns.

Scope: 806 GitHub stars, Apache-2.0, 116 plugins, Python-codebase tooling, maintained since October 2025.

Differs from seeds: Unlike superpowers or spec-driver (Archetype 1 enforcement frameworks), ccplugins-awesome is an Archetype 4 marketplace — no methodology, no workflow phases, no hooks — just a curated collection of installable atomic capability plugins. Closest to agent-os in that the value is content/curation rather than machinery, but agent-os is a 5-command scaffold system while this is a 116-plugin catalog.

01

Overview

ccplugins/awesome-claude-code-plugins — Overview

Origin

Created by the ccplugins organization (a community GitHub org) in October 2025, shortly after Anthropic's public Claude Code Plugin format was announced. The homepage is claudecodeplugins.dev.

Philosophy

"Claude Code Plugin is a lightweight package that lets you customize and share your Claude Code setup. Each plugin can include any combination of: Slash Commands, Subagents, MCP Servers, Hooks."

The repo operates on an "awesome-list" model — inspired by the broader awesome-X ecosystem on GitHub — where the README is both the discovery mechanism and the navigation index. Each listed plugin is a real, installable subdirectory in plugins/.

Use Case Orientation

The catalog explicitly identifies the use cases its plugins serve:

  • Enforce Standards — hooks/workflows for teams
  • Support Users — slash commands simplifying SDK usage
  • Share Workflows — debugging setups, deployment scripts, testing harnesses
  • Connect Tools — internal systems via MCP servers
  • Bundle Customizations — combine extensions for cohesive dev experience

Categories (13 verticals)

  1. Official Claude Code Plugins (5 first-party reference plugins)
  2. Workflow Orchestration (8 plugins)
  3. Automation DevOps (5 plugins)
  4. Business Sales (8 plugins)
  5. Code Quality Testing (16 plugins)
  6. Data Analytics (5 plugins)
  7. Design UX (8 plugins)
  8. Development Engineering (15 plugins)
  9. Documentation (8 plugins)
  10. Git Workflow (11 plugins)
  11. Marketing Growth (7 plugins)
  12. Project & Product Management (7 plugins)
  13. Security, Compliance & Legal (13 plugins)

Official vs Community

The 5 "Official Claude Code Plugins" carry special status: agent-sdk-dev, pr-review-toolkit, commit-commands, feature-dev, and security-guidance. These appear to be Anthropic-affiliated or reference-quality implementations.

02

Architecture

ccplugins/awesome-claude-code-plugins — Architecture

Distribution

  • Type: Claude Code Plugin marketplace + standalone-repo
  • Install: /plugin marketplace add ccplugins/awesome-claude-code-plugins then /plugin install <plugin-name>@awesome-claude-code-plugins
  • Homepage: https://claudecodeplugins.dev
  • License: Apache-2.0

Repository Structure

ccplugins/awesome-claude-code-plugins/
├── .claude-plugin/
│   └── marketplace.json        # Plugin registry manifest
├── plugins/
│   ├── agent-sdk-dev/          # Official: Claude Agent SDK plugin
│   │   ├── .claude-plugin/     # Plugin metadata
│   │   ├── agents/             # Subagent definitions
│   │   └── commands/           # Slash commands
│   ├── feature-dev/            # Official: Feature development workflow
│   │   ├── agents/             # 4 specialized agents
│   │   └── commands/           # Feature dev commands
│   ├── pr-review-toolkit/
│   ├── commit-commands/
│   ├── security-guidance/
│   └── ... (111 more plugins)
├── README.md                   # Catalog + discovery index
└── README-zh.md               # Chinese translation

Plugin Structure Convention

Each plugin follows the standard Claude Code plugin layout:

<plugin-name>/
├── .claude-plugin/             # Required: plugin.json manifest
├── agents/                     # Optional: subagent .md files
├── commands/                   # Optional: slash command .md files
└── hooks/                      # Optional: hook definitions

Required Runtime

  • No runtime requirements for catalog consumption
  • Individual plugins may require tools (e.g., git, gh CLI, node)
  • Python tooling in repo root for plugin validation/generation

Target AI Tools

  • Primarily: Claude Code (via /plugin command)
  • The plugin format is Claude Code-specific (not cross-tool)

Marketplace Manifest

marketplace.json registers the repo as a marketplace with all 116+ plugins enumerated with name, source path, description, version, author, category, homepage, and keywords.

03

Components

ccplugins/awesome-claude-code-plugins — Components

Plugin Count: 116

Official Claude Code Plugins (5)

Plugin Purpose
agent-sdk-dev Verify and scaffold Claude Agent SDK apps (Python/TypeScript)
pr-review-toolkit PR review workflows and code review assistance
commit-commands Git commit message generation and workflow
feature-dev Full feature development lifecycle with 4 specialized agents
security-guidance Security review and vulnerability guidance

Workflow Orchestration (8)

Plugin Purpose
angelos-symbo Symbolic workflow orchestration
ceo-quality-controller-agent Quality control from CEO perspective
claude-desktop-extension Desktop environment extension
lyra Master-level AI prompt optimization specialist
model-context-protocol-mcp-expert MCP server expert assistant
problem-solver-specialist Systematic problem-solving
studio-coach Creative workflow coaching
ultrathink Deep thinking and analysis mode

Code Quality Testing (16)

Plugin Purpose
api-tester API endpoint testing
bug-detective Bug investigation and root cause analysis
code-review / code-review-assistant / code-reviewer Code review (3 variants)
database-performance-optimizer DB query optimization
debug-session / debugger Interactive debugging sessions
double-check Verification and validation
optimize Code optimization
performance-benchmarker Performance benchmarking
refractor Refactoring assistant
test-file / test-results-analyzer / test-writer-fixer / unit-test-generator Test lifecycle (4 variants)

Development Engineering (15)

Plugin Purpose
ai-engineer AI application development
api-integration-specialist API integration patterns
backend-architect Backend system architecture
code-architect Code architecture design
desktop-app-dev Desktop app development
enterprise-integrator-architect Enterprise integration patterns
flutter-mobile-app-dev Flutter mobile development
frontend-developer Frontend development
mobile-app-builder Mobile application building
project-curator Project curation and maintenance
python-expert Python expertise
rapid-prototyper Rapid prototyping
react-native-dev React Native development
vision-specialist Computer vision integration
web-dev Web development

Security, Compliance & Legal (13)

Plugin Purpose
ai-ethics-governance-specialist AI ethics and governance
audit Code/system auditing
compliance-automation-specialist Compliance automation
security-advisor Security advisory
security-auditor Security audit
security-reviewer Security review
(7 more in category)

Git Workflow (11)

Plugin Purpose
analyze-issue GitHub issue analysis
bug-fix Bug fix workflow
commit Commit generation
create-pr PR creation
(7 more)

feature-dev Agent Details (4 subagents)

Agent Purpose
code-architect.md Architecture design decisions
code-explorer.md Codebase exploration and understanding
code-reviewer.md Code review within feature workflow
feature-dev.md Feature development orchestration

agent-sdk-dev Subagents (2)

Agent Purpose
agent-sdk-verifier-py.md Verify Python Agent SDK app configuration
agent-sdk-verifier-ts.md Verify TypeScript Agent SDK app configuration
05

Prompts

ccplugins/awesome-claude-code-plugins — Prompts

Verbatim Excerpt 1: agent-sdk-verifier-py Agent

File: plugins/agent-sdk-dev/agents/agent-sdk-verifier-py.md Technique: Role-persona + structured checklist (Archetype 3 verification agent)

---
name: agent-sdk-verifier-py
description: Use this agent to verify that a Python Agent SDK application is properly
configured, follows SDK best practices and documentation recommendations, and is ready
for deployment or testing. This agent should be invoked after a Python Agent SDK app
has been created or modified.
model: sonnet
---

You are a Python Agent SDK application verifier. Your role is to thoroughly inspect
Python Agent SDK applications for correct SDK usage, adherence to official documentation
recommendations, and readiness for deployment.

## Verification Focus

Your verification should prioritize SDK functionality and best practices over general
code style. Focus on:

1. **SDK Installation and Configuration**:
   - Verify `claude-agent-sdk` is installed (check requirements.txt, pyproject.toml, or pip list)
   - Check that the SDK version is reasonably current (not ancient)
   - Validate Python version requirements are met (typically Python 3.8+)
   - Confirm virtual environment is recommended/documented if applicable

2. **Python Environment Setup**:
   - Check for requirements.txt or pyproject.toml
   - Verify dependencies are properly specified
   - Ensure Python version constraints are documented if needed

3. **SDK Usage and Patterns**:
   - Verify correct imports from `claude_agent_sdk`
   - Check that agents are properly initialized according to SDK docs
   - Validate that agent configuration follows SDK patterns
   - Ensure SDK methods are called correctly with proper parameters
   - Check for proper handling of agent responses (streaming vs single mode)
   - Verify permissions are configured correctly if used
   - Validate MCP server integration if present

4. **Environment and Security**:
   - Check that `.env.example` exists with `ANTHROPIC_API_KEY`
   - Verify `.env` is in `.gitignore`
   - Ensure API keys are not hardcoded in source files

Prompting technique: Role persona + numbered checklist with emphasis headers. Uses model: sonnet front-matter to lock model. Focuses verification on SDK-specific patterns, not general code style — an explicit anti-scope statement.

Verbatim Excerpt 2: marketplace.json Plugin Registry

File: .claude-plugin/marketplace.json Technique: Declarative catalog manifest (not a prompt — metadata for Claude Code plugin system)

{
  "name": "awesome-claude-code-plugins",
  "owner": {
    "name": "Awesome Claude Code Plugins",
    "email": "support@claudecodeplugins.dev"
  },
  "metadata": {
    "description": "Awesome Claude Code plugins — a curated list of slash commands, subagents, MCP servers, and hooks for Claude Code",
    "version": "0.0.1",
    "homepage": "https://claudecodeplugins.dev"
  },
  "plugins": [
    {
      "name": "documentation-generator",
      "source": "./plugins/documentation-generator",
      "description": "Create comprehensive documentation for code, APIs, and projects.",
      "version": "1.0.0",
      "author": { "name": "Anonymous" },
      "category": "Documentation",
      ...
    },
    ...
  ]
}

Note: The marketplace.json is the discovery layer — it enables /plugin marketplace add ccplugins/awesome-claude-code-plugins to register all 116 plugins with Claude Code's plugin system, after which each individual plugin can be installed by name.

09

Uniqueness

ccplugins/awesome-claude-code-plugins — Uniqueness & Positioning

Differs from Seeds

The closest seed is claude-conductor (Archetype 4 — markdown scaffold, zero primitives) but ccplugins-awesome is structurally the opposite: it provides 116 installable plugins with real agent/command code, not just markdown templates. Unlike superpowers or spec-driver (Archetype 1 enforcement frameworks), this repo imposes no methodology — it is a curated toolkit, not a workflow. Unlike claude-flow or taskmaster-ai (Archetype 3 MCP-anchored), plugins here are standalone subagents, not MCP tool servers.

The most accurate positioning: community plugin registry for Claude Code, analogous to npm for Node.js but specifically for Claude Code's plugin format. First-mover in this niche.

Distinctive Properties

  1. Dual nature: Both an awesome-list catalog AND the actual plugin code — browsing and installing happen in the same repo
  2. Official + community mix: 5 official reference plugins + 111 community plugins, with official ones serving as quality anchors
  3. 13-category taxonomy: Deliberate vertical segmentation (Business Sales, Design UX, Security/Compliance, etc.) suggests enterprise audience targeting
  4. Per-plugin model locking: model: sonnet in agent front-matter enables plugin authors to specify the right model per use case
  5. Chinese translation: README-zh.md signals international user base and community reach

Observable Failure Modes

  • Quality inconsistency: With 116 plugins from multiple anonymous contributors, quality varies widely — no review gate is visible in the repo
  • Stale plugins: The repo was last pushed in October 2025 but individual plugins may not track Claude Code API changes
  • No integration testing: No CI/CD for verifying plugin correctness against the Claude Code plugin spec
  • Plugin naming collisions: Multiple code-review plugins (code-review, code-review-assistant, code-reviewer) create confusion

Competitive Positioning

  • Directly competes with anthropics/skills for the "plugin marketplace" mindshare, but in the Claude Code Plugin format rather than the Agent Skills format
  • The anthropics-knowledge-work-plugins fills the official role; this fills the community/ecosystem role
  • anthropics/claude-plugins (404 as of 2026-05-26) would have been the direct Anthropic-official competitor — its absence leaves ccplugins-awesome as the largest public registry
04

Workflow

ccplugins/awesome-claude-code-plugins — Workflow

No Centralized Workflow

This repository is a catalog, not a workflow framework. There is no enforced development lifecycle, phase sequence, or approval gates at the repo level.

Per-Plugin Workflow Patterns

Individual plugins define their own workflows. Notable patterns:

agent-sdk-dev Plugin Workflow

  1. User installs plugin: /plugin install agent-sdk-dev@awesome-claude-code-plugins
  2. User invokes command: /new-sdk-app to scaffold a new Agent SDK application
  3. After creation, subagent agent-sdk-verifier-py or agent-sdk-verifier-ts validates:
    • SDK installation and configuration
    • Python/TypeScript environment setup
    • SDK usage patterns (imports, initialization, agent methods)
    • Code quality and security (API key handling)
    • README documentation completeness
  4. Output: validated, deployment-ready Agent SDK application

feature-dev Plugin Workflow

  1. feature-dev.md agent orchestrates feature implementation
  2. Delegates to code-architect.md for design decisions
  3. Delegates to code-explorer.md for codebase discovery
  4. Delegates to code-reviewer.md for review
  5. Commands handle specific feature dev sub-tasks

Approval Gates

No framework-level approval gates. Individual plugins may implement human review checkpoints in their agent instructions.

Artifacts Per Phase

Phase Artifact
Plugin install Claude Code plugin context injection
/command invocation Context-specific output per command definition
Subagent invocation Specialized analysis report or code output

Discovery Workflow

The README serves as the primary discovery artifact:

  1. Browse categories in README
  2. Click plugin link to see plugin directory
  3. Install via /plugin install or browse plugin.json for details
06

Memory Context

ccplugins/awesome-claude-code-plugins — Memory & Context

State Model

No framework-level memory system. Individual plugins inject their context through the standard Claude Code plugin mechanism: when a plugin is installed, its agents and commands are available in the Claude Code session context.

Plugin Context Injection

The Claude Code plugin system handles context loading:

  1. At session start, all installed plugin agents are registered as available subagents
  2. Commands are available as slash-command shortcuts
  3. Agent descriptions (from YAML front-matter in .md files) serve as the discovery index

Per-Plugin State

Individual plugins operate statelessly by default. The agent-sdk-dev plugin:

  • Reads project files at invocation time
  • Produces a verification report but does not persist it
  • No session-to-session memory

Context Strategy

The agent-sdk-verifier-py subagent uses a checklist-driven context strategy:

  • Reads requirements.txt, pyproject.toml, .gitignore, .env.example in context
  • Produces structured findings but does not write back to the project

No Compaction Handling

No mention of context compaction in any plugin definition. Individual plugins are designed as single-task agents that complete within a single context window.

Cross-Session Handoff

None. Each plugin invocation is stateless. The value is the agent's instructions (loaded at invocation), not persistent state.

07

Orchestration

ccplugins/awesome-claude-code-plugins — Orchestration

Multi-Agent Capability

Limited multi-agent support within individual plugins. The feature-dev plugin ships 4 subagents that can be invoked by the orchestrating feature-dev.md agent to delegate specialized tasks.

Orchestration Pattern

Sequential within plugins that use multiple agents (e.g., feature-dev delegates to code-architect → code-explorer → code-reviewer). No parallel fan-out at the catalog level.

Isolation Mechanism

None. All agents operate in-place within Claude Code's existing session context. No worktrees, containers, or process isolation.

Multi-Model

Per-agent model locking: The agent-sdk-verifier-py agent front-matter specifies model: sonnet. Other agents may have different model assignments. This is agent-level, not system-level multi-model routing.

Subagent Definition Format

skill-md / persona-md: Each subagent is a .md file with YAML front-matter (name, description, model) followed by the agent system prompt. This is the standard Claude Code subagent format.

Spawn Mechanism

Claude Code native: Subagents are invoked through Claude Code's built-in agent dispatch mechanism when the orchestrating agent delegates to them.

Execution Mode

Event-driven / one-shot: Each plugin is invoked on demand by the user. No background daemons, no continuous loops.

Consensus

None. No multi-agent consensus mechanisms.

Prompt Chaining

Yes, within feature-dev: The feature-dev orchestration chains across 4 subagents — the output of code-architect informs the code generation task, which is then reviewed by code-reviewer.

08

Ui Cli Surface

ccplugins/awesome-claude-code-plugins — UI/CLI Surface

Dedicated CLI Binary

None. No standalone CLI binary. The repo is accessed entirely through Claude Code's /plugin command.

Install Interface

# Register marketplace
/plugin marketplace add ccplugins/awesome-claude-code-plugins

# Browse plugins
/plugin browse awesome-claude-code-plugins

# Install a specific plugin
/plugin install feature-dev@awesome-claude-code-plugins
/plugin install agent-sdk-dev@awesome-claude-code-plugins

Web Interface

The companion website https://claudecodeplugins.dev provides a web-based browsing experience for the plugin catalog. Not a local dashboard — it's an external web property.

IDE Integration

  • Target IDE: Claude Code
  • Integration method: Standard Claude Code Plugin protocol
  • Plugins appear in Claude Code's slash command menu once installed
  • Subagents become available in Claude Code's agent dispatch

Observability

None at framework level. Individual plugins do not ship logging, metrics, or audit trails.

Discovery Interface

The README serves as the primary discovery UI — a structured Awesome-list with categories, clickable links to plugin subdirectories, and use-case descriptions.

Related frameworks

same archetype · same primary tool · same memory type

Spec Kit ★ 106k
A2 Mirror cmd+skill

Turns a natural-language feature description into a complete, versioned, AI-executable specification pipeline installable for 30+…

OpenSpec ★ 51k
A2 Mirror cmd+skill

Adds a lightweight spec layer so AI coding assistants and humans agree on what to build before any code is written.

ECC (Everything Claude Code) ★ 193k
A2 Mirror cmd+skill

Comprehensive harness-native operator system: 246 skills + 61 agents + continuous learning hooks + multi-model routing across 8…

Gemini CLI (Google) ★ 105k
A2 Mirror cmd+skill

Bring the full power of Gemini into the terminal with a free tier, Google Search grounding, and extensible MCP support.

OpenAI Codex CLI ★ 86k
A2 Mirror cmd+skill

Give developers a sandboxed, locally-running OpenAI coding agent with approval gates and skill orchestration.

cursorrules v5 (kinopeee) ★ 1.1k
A2 Mirror cmd+skill

Bilingual (ja/en) Cursor rule set with tricolor task classification, security-first prompt injection defense, and structured git…