convez.ai
SkillAutomaçãoIntermediário
RealDougEubanks

Claude Marketplace de Skills

RealDougEubanks/ClaudeMarketplace

Marketplace comunitário de skills reutilizáveis para Claude Code

Ver no GitHub
BomPluginScore · de 0 a 100

Coleção comunitária de skills personalizadas para Claude Code, a ferramenta CLI da Anthropic. Skills são templates de prompts reutilizáveis que estendem capacidades do Claude Code via comandos slash, sem exigir servidores MCP ou APIs externas. Inclui automação de workflows, geração de código, auditorias de segurança e documentação.

Instalação

$npx convez-ai RealDougEubanks/ClaudeMarketplace

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
1
Acompanhando
0
Saúde
71%
Último commit
há 2 semanas
Versão
v1.0.8
Issues abertas
2
Contribuidores
3

Casos de uso

  • Estender funcionalidades do Claude Code com skills customizados
  • Compartilhar workflows, checklists e templates de código entre times
  • Automatizar auditorias de segurança, testes e deploys via prompt instructions
  • Padronizar code review, naming conventions e regras de projeto

Veredito

Marketplace bem estruturado para quem já usa Claude Code e quer criar/compartilhar skills. Excelente para times que precisam padronizar workflows e automation, mas requer familiaridade com Claude Code CLI e script shell. Comunidade ainda pequena, então o catálogo de skills públicas é limitado.

README

A tradução para o português deste README ainda está na fila.

Claude Code Skills Marketplace

A community-driven collection of custom skills for Claude Code — Anthropic's CLI tool that lets you work with Claude directly in your terminal and editor.

Prerequisites

  • Claude Code installed and authenticated
  • Git with SSH configured (for the marketplace source URL), or use the HTTPS URL below
  • No other dependencies required

What are Skills?

Skills are reusable prompt templates that extend Claude Code's capabilities. They let you package expert instructions into shareable, versioned modules that anyone can invoke with a slash command.

Skills vs Plugins: Internally, Claude Code calls these "plugins" — you'll see enabledPlugins in settings.json and .claude-plugin/ directories in the repo. Skills are plugins implemented purely as prompt instructions, with no MCP server or external API required.

Examples of what skills can do:

  • Enforce project-specific code review checklists
  • Generate boilerplate tailored to your stack
  • Run multi-step workflows (test, lint, commit, deploy)
  • Automate documentation generation
  • Perform security audits with custom rulesets

Repository Structure

ClaudeMarketplace/
├── skills/                         # Published skills
│   ├── registry.json               # Index of all available skills
│   └── example-skill/              # One directory per skill
│       ├── commands/
│       │   └── example-skill.md    # Skill prompt with YAML frontmatter
│       ├── .claude-plugin/
│       │   └── plugin.json         # Claude Code plugin manifest
│       ├── metadata.json           # Name, version, author, tags, etc.
│       └── README.md               # Human-readable documentation
├── templates/                      # Starter templates for new skills
│   ├── skill.md                    # Used by new-skill.sh to scaffold commands/<name>.md
│   └── metadata.json
├── schema/
│   └── metadata.schema.json        # JSON Schema for metadata validation
├── scripts/
│   ├── validate.sh                 # Validate a skill's structure
│   ├── new-skill.sh                # Scaffold a new skill from templates
│   ├── check-registry.sh           # Verify registry.json consistency
│   ├── validate-all.sh             # Run all validation checks
│   ├── scan-prompts.sh             # Prompt safety scanner
│   ├── sync-versions.sh            # Sync versions across metadata files
│   └── generate-changelog-entry.sh # Generate a changelog entry from git log
├── CONTRIBUTING.md                 # How to submit a skill
└── LICENSE                         # MIT

Available Skills

The example-skill is a contributor reference — it demonstrates the expected file structure but is not a functional skill.

Base (always-on context)

SkillCommandDescription
golden-rules/golden-rulesInstalls mandatory security, coding, naming, and design standards into CLAUDE.md as always-on context for every Claude Code session

Workflow

SkillCommandDescription
agent-based-development/agent-based-developmentFull async multi-agent development workflow: Planning → Design → Dev → Security/Tech Review loop with file-based handoffs and release-branch Git model
git-workflow/git-workflowEnforces the release-branch Git model: scaffold feature branches, open PRs with review checks, cut releases with tags, and view workflow reference
adr/adrCreates and maintains Architecture Decision Records (ADRs) in docs/decisions/ using the MADR format. Supports creating, listing, updating, superseding, and searching ADRs
api-design/api-designDesigns REST, GraphQL, and gRPC APIs (OpenAPI/schema/proto output) and reviews existing APIs for consistency, best practices, and breaking change risks
architecture-design/architecture-designDesigns new systems from requirements: C4 model diagrams, service boundaries, API contracts, data design, failure modes, and cross-cutting concerns
changelog-generator/changelog-generatorGenerates a structured CHANGELOG.md following Keep a Changelog format from git history and ABD handoff artifacts
database-design/database-designDesigns database schemas from domain requirements (ERD, indexes, migrations, security) or reviews existing schemas for normalization issues, missing indexes, unsafe migrations, and scalability risks
incident-report/incident-reportGenerates professional incident reports using customizable templates. Supports outage, security, performance, and data-loss incident types
requirements-generator/requirements-generatorGenerates structured requirements documents with functional and non-functional requirements, Gherkin acceptance criteria, edge cases, and out-of-scope items

Standards

SkillCommandDescription
accessibility/accessibilityAudits code for WCAG 2.2 AA compliance and provides design guidance for accessible components. Covers semantic HTML, ARIA, keyboard nav, contrast, focus management, and motion
architecture-review/architecture-reviewAudits existing architecture for anti-patterns, scalability and reliability risks, and testability gaps. Graded findings with migration paths and a to-be diagram
best-practices/best-practicesHolistic codebase audit that auto-detects the stack and produces a prioritized improvement roadmap with level-of-effort estimates
code-review/code-reviewStructured engineering code review covering readability, complexity, test gaps, SOLID principles, and API consistency
mvp-readiness/mvp-readinessRuns a structured MVP quality-gate audit covering stability, security, logging, docs, and implementation integrity. Reports pass/fail with evidence
pre-commit/pre-commitFast pre-commit quality gate: scans staged files for secrets, dead code, naming issues, merge conflict markers, and direct-to-main commits. Installs as a git hook via /pre-commit install
test-writer/test-writerGenerates comprehensive unit and integration tests for a given file or function, auto-detecting the project test framework and matching existing test style

Security

SkillCommandDescription
dependency-audit/dependency-auditAudits project dependencies across package.json, requirements.txt, go.mod, and Gemfile for unpinned versions, deprecated packages, missing lockfiles, and known CVEs
full-security-review/full-security-reviewStructured security audit covering injection, auth, secrets, input validation, dependencies, and cryptography. Produces severity-graded findings

Productivity

SkillCommandDescription
doc-refresh/doc-refreshComplete documentation refresh — audits stale docs, creates missing docs, rewrites for a 2am on-call engineer with zero assumed context. Installs as a pre-commit hook via /doc-refresh install
log-correlation/log-correlationCorrelates and troubleshoots logs across OS (Linux/macOS), AWS (CloudWatch, CloudTrail, ALB, Lambda), application (JSON, logfmt), and web servers (Nginx, Apache)
onboarding/onboardingGenerates a comprehensive developer onboarding guide (ONBOARDING.md) by reading the codebase: directory map, entry points, environment variables, key commands, and architecture overview

Git Hooks

Two skills can install themselves as git hooks so they run automatically on every commit without you having to invoke them manually.

SkillHook typeHook fileWhat it does automatically
pre-commitpre-commit.git/hooks/pre-commitScans staged files for secrets, dead code, naming issues, conflict markers, and direct-to-main commits. Blocks the commit if a BLOCKER is found.
doc-refreshpre-commit.git/hooks/pre-commitRefreshes all project documentation before the commit finalises and auto-stages any updated doc files so they land in the same commit as the code.

Note: Both hooks use .git/hooks/pre-commit. If you want both to run, install pre-commit first, then manually merge the two scripts, or run /doc-refresh install which will warn you if a hook already exists.

Installing a hook

/pre-commit install
/doc-refresh install

Each command writes a shell script to .git/hooks/ and makes it executable. The hook runs automatically on every git commit from that point on. Both hooks fail gracefully — if Claude Code is unavailable the commit proceeds with a warning rather than being blocked.

Skipping a hook for one commit

Both hooks respect an environment variable escape hatch:

SkillSkip variable
pre-commitgit commit --no-verify
doc-refreshSKIP_DOC_REFRESH=1 git commit ...

Use --no-verify sparingly — it bypasses all hooks including the secret scanner. Prefer the skill-specific skip variable when you only need to skip one hook.

Uninstalling a hook

/pre-commit uninstall
/doc-refresh uninstall

Hook scope

Git hooks are stored in .git/hooks/, which is not committed to the repository. Each team member must run the install command in their own local clone. To automate this for the whole team, add the install command to your project's setup or bootstrap script.


How Base Skills Work

Skills with "category": "base" (like golden-rules) do two things when enabled via the marketplace:

  1. Register as a slash command (e.g. /golden-rules) so you can invoke it on demand.
  2. When invoked, append the skill content to CLAUDE.md in your project root.

Because Claude Code loads CLAUDE.md automatically at the start of every session, base skills become always-on context — no invocation required after the first run.


Why Marketplace Format?

Skills in this repo are distributed as a Claude Code marketplace rather than as individually installed files. This was a deliberate design decision:

Skills stay automatically up to date. With "autoUpdate": true, Claude Code syncs with this repo whenever it pulls updates. Any improvement to a skill — better instructions, new capabilities, bug fixes — is available immediately without any action from the user. There is no "reinstall" step.

Skills are passive — there is no overhead to having them enabled. A skill is just a slash command. It does nothing until you invoke it. Having 22 skills enabled globally costs nothing at runtime: no background processes, no memory usage, no effect on Claude's behavior unless you type the command. The only practical consideration is 22 extra entries in the slash command autocomplete list.

You control which skills are enabled. You can enable all of them globally, a curated subset, or configure different skills per project. See Selective Installation below.


Quick Start

Browse Skills

Look through the skills/ directory or check skills/registry.json for a full index.

Install via Claude Code Marketplace

Skills are distributed through the Claude Code marketplace system. Add this marketplace to your ~/.claude/settings.json:

{
  "extraKnownMarketplaces": {
    "claude-skills-marketplace": {
      "source": {
        "source": "git",
        "url": "git@github.com:RealDougEubanks/ClaudeMarketplace.git"
      },
      "autoUpdate": true
    }
  }
}

No SSH? Use the HTTPS URL instead: "url": "https://github.com/RealDougEubanks/ClaudeMarketplace.git"

Then enable the skills you want under enabledPlugins. You can enable all of them, or just the ones relevant to your work:

{
  "enabledPlugins": {
    "golden-rules@claude-skills-marketplace": true,
    "code-review@claude-skills-marketplace": true,
    "full-security-review@claude-skills-marketplace": true
  }
}

Once enabled, skills are available as slash commands in any Claude Code session:

/code-review          ← runs a structured code review on the current file or selection
/full-security-review ← audits the codebase for security issues
/test-writer          ← generates tests for a given file or function

Selective Installation

You don't have to enable everything. There are three common patterns:

Enable all skills globally — add every skill to ~/.claude/settings.json. All slash commands are available in every project, always up to date.

Enable a curated global set — enable only the skills you use regularly (e.g. golden-rules, code-review, full-security-review) in ~/.claude/settings.json, and skip the rest.

Per-project overrides — add an enabledPlugins block to a project's .claude/settings.json to enable skills only for that project. Project settings layer on top of your global config.

// .claude/settings.json in a specific project
{
  "enabledPlugins": {
    "accessibility@claude-skills-marketplace": true,
    "database-design@claude-skills-marketplace": true
  }
}

Create Your Own Skill

# Scaffold from templates
./scripts/new-skill.sh my-new-skill

# Edit the generated files:
# - skills/my-new-skill/commands/my-new-skill.md  → instructions Claude follows
# - skills/my-new-skill/metadata.json             → name, version, category, tags, tools
# - skills/my-new-skill/README.md                 → human-readable docs

# Validate structure
./scripts/validate.sh skills/my-new-skill

# Check registry consistency
./scripts/check-registry.sh

See CONTRIBUTING.md for the full submission guide.

Skill Anatomy

Every skill has four files:

FilePurpose
commands/<name>.mdThe prompt with YAML frontmatter — what Claude executes
metadata.jsonMachine-readable metadata (name, version, tags, tools)
.claude-plugin/plugin.jsonClaude Code plugin manifest for discovery
README.mdHuman-readable docs (usage, examples, installation notes)

metadata.json

{
  "name": "my-skill",
  "version": "1.0.0",
  "description": "What the skill does in one sentence",
  "author": {
    "name": "Your Name",
    "github": "your-username"
  },
  "license": "MIT",
  "tags": ["category"],
  "commands": ["/my-skill"],
  "tools": ["Bash", "Read"]
}

See schema/metadata.schema.json for the full validation schema.

Contributing

We welcome contributions! Please read CONTRIBUTING.md before submitting a pull request.

TL;DR:

  1. Run ./scripts/new-skill.sh your-skill-name to scaffold
  2. Write your commands/your-skill-name.md, metadata.json, and README.md
  3. Validate with ./scripts/validate.sh skills/your-skill-name
  4. Add to skills/registry.json
  5. Open a PR

License

This project is licensed under the MIT License — see LICENSE for details.

Ver o original no GitHub

Bom para

Relacionados