convez.ai
SkillDevOps & InfraestruturaIntermediário
Shearerbeard

Claude Skills - Biblioteca de Skills para Desenvolvimento

Shearerbeard/claude-skills

Skills compostas para qualidade, review e design de código + docs

Ver no GitHub
InicialPluginScore · de 0 a 100

Coleção de skills (competências) reutilizáveis para Claude Code, voltadas a qualidade, revisão e design de código em Python, Rust e documentação. Inclui verificações de anti-padrões, linting de prosa, planejamento disciplinado e orquestração de workflows. Funciona como um marketplace local que se integra ao arquivo de configuração do Claude.

Instalação

$npx convez-ai Shearerbeard/claude-skills

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
2
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 2 semanas
Versão
—
Issues abertas
1
Contribuidores
2

Casos de uso

  • Revisar PRs com probes específicas de linguagem (Python, Rust)
  • Garantir padrões de design de tipos e async em Rust
  • Auditar código para anti-padrões (clone escapes, wildcards, transitive deps)
  • Validar qualidade de documentação com checklist de 24 itens
  • Remover padrões típicos de escrita IA de textos para produção
  • Planejamento de escopo com verificação de blast radius

Veredito

Arquitetura sólida de skills compostas que se beneficia de triggers bem definidos e chaining automático. Ideal para times que usam Claude Code e querem enforçar padrões de qualidade; cobertura forte em Rust e Python, com foco em anti-padrões reais. Documentação é técnica mas clara; requer familiaridade com Claude Code e workflow local.

README

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

Personal Skills Library

Model-invoked skills for Claude Code, OpenCode, and Codex. Registered as a local marketplace (my-skills) in ~/.claude/settings.json.

Skills

SkillPluginTriggerPurpose
python-qualitypythonwriting .pyToolchain (uv/ruff) + code patterns + LLM anti-patterns
python-reviewpythonreviewing Python7 Python-specific gate probes
rust-qualityrustwriting .rsAnti-pattern catch list (clone escapes, wildcards, transitive deps)
rust-asyncrustasync, tokio, Send+SyncCooperative scheduling, Send+'static, spawn_blocking vs rayon, async Drop
rust-designrustwriting/designing/reviewing typesADT-first workflow, constrained types, railway programming, 6-step clone avoidance
rust-reviewrustreviewing Rust7 Rust-specific gate probes
rust-modulesrustRust module layoutModern file layout, re-exports, type co-location
docs-bustestdocsdocs review / updates24-item bus test for documentation quality
prose-lintdocsVale / prose lintDeterministic AI-tell checks for docs and emitted prose
humanizerdocspublishable proseRemove AI writing patterns from user-facing text
mermaiddocs.mmd files / diagramsRender and open Mermaid diagrams
plan-disciplineworkflowplanning / design / scopeVerification-first, scope interview, blast radius
gate-probesworkflowcommit / review / PR7 universal quality probes + surgical discipline
skill-retroworkflow"retro my skills"Audit how skills triggered and performed in a session; files retros under feedback/

Two more plugins ship LSP configs rather than skills: vale-lsp (Vale prose diagnostics) and haskell-lsp (Haskell Language Server).

How Skills Chain

Skills are designed to compose. A single prompt can load 2-3 skills when the content spans multiple domains.

Rust stack

User prompt → rust-design   (type modeling, ADTs, constrained types)
            → rust-async    (Send+Sync, spawn, cooperative scheduling)
            → rust-quality  (anti-pattern catch list)
            → rust-review   (gate checklist, loaded at review time)
            → rust-modules  (file layout, triggered on mod/split/create)

Common combos:

  • "design an async connection pool with proper types and Send bounds" → rust-design + rust-async
  • "create a new billing module with Invoice state machine, avoid clone escapes" → rust-design + rust-modules + rust-quality
  • "review this PR for clone issues and wildcard matches" → rust-review → rust-quality (loaded internally)

Plan stack

User prompt → plan-discipline   (scope interview, blast radius, gate placement)
            → gate-probes       (exit check at each gate: sprawl, duplication, coherence)
                                   → rust-review / python-review (language-specific)

Async concerns

rust-async is separate from rust-design. Design triggers ("type", "enum", "struct") fire rust-design. Async triggers ("tokio", "spawn", "Send+Sync") fire rust-async. A prompt with both triggers loads both.

Writing Skill Descriptions

The description field in SKILL.md frontmatter is model-facing routing text. Claude Code and OpenCode both rely on model judgment over skill metadata; words like "triggered", "Triggers", "auto-triggered", and "activates" have no special runtime meaning. Claude Code can also use when_to_use; OpenCode ignores that field, so keep critical routing phrases in description.

Follow these conventions:

  • Lead with concrete user phrases: "Use when the user says 'design a Rust type', 'model this in Rust'", not "Triggers when working with Rust."
  • List keywords and verbs the user actually types: "async function", "tokio", "spawn a task". The model matches against these.
  • Front-load trigger conditions, then describe content: trigger phrases first, then "Contains X, Y, Z."
  • Mention sibling skills for pairing: "Pair with rust-quality during implementation."
  • Avoid abstract state language: "entering plan mode", "at commit boundaries". The trigger system can't observe internal state transitions.

Plan mode hooks exist in Claude Code but are buggy: EnterPlanMode hook output is ignored (claude-code#41051), and user-initiated /plan doesn't fire hooks (claude-code#15660). Invoke plan-discipline manually when its hard blockers matter; plan-mode prompts often make the skill look redundant to the model.

CLAUDE.md Guidelines

CLAUDE.md files (project-level and repo-level) should route to skills, not duplicate them:

## Planning

Before non-trivial code work, load `plan-discipline`. It enforces the scope
interview, verification framing, blast-radius scan, gate placement, and review
checkpoints. It is the single source of truth for planning workflow; do not
duplicate its rules here.

This pattern keeps the skill as the single source of truth. Duplicating skill rules in CLAUDE.md causes the model to follow the CLAUDE.md version (which is always active) and never load the skill, missing gate types, placement rules, and templates.

Review Gate Types

plan-discipline defines five gate types for structuring a plan. Each stage in the plan template specifies which gates apply and whether the user must be pulled in:

GateWhoWhat
S Self-reviewAgentRun deterministic tools (lint, fmt, type check, build, test). Fix all failures.
A Agent second opinionContext-isolated subagentReview diff with fresh eyes. No prior implementation context. Find issues or sign off.
M Manual testingAgentExercise the feature, report behavior, verify success criteria.
U User reviewUserPause and present diffs + findings. Highlight highest-risk changes. Await approval.
T User testingUserPrescribe specific manual testing steps. Be explicit; don't assume the user knows how to test.

Installation

Claude Code: marketplace plugin via ~/.claude/settings.json:

"enabledPlugins": {
  "python@my-skills": true,
  "docs@my-skills": true,
  "rust@my-skills": true,
  "workflow@my-skills": true
},
"extraKnownMarketplaces": {
  "my-skills": {
    "source": { "source": "directory", "path": "/absolute/path/to/claude-skills" }
  }
}

OpenCode or Codex:

./bin/install-skills opencode   # ~/.config/opencode/skills/
./bin/install-skills codex      # ~/.codex/skills/

Quality Gates

Pre-commit Hooks (Recommended)

Install once per checkout to run all checks automatically on commit:

brew install pre-commit betterleaks
./bin/setup-hooks

Hooks run on every commit:

  • betterleaks: secret scanning (BPE-based, 98.6% recall)
  • asciicheck: non-ASCII artifact detection (smart quotes, em dashes, non-breaking spaces)
  • check-prose: Vale prose quality on markdown diffs (skips SKILL.md and code blocks)
  • vale-commit-msg: commit message quality (ai-tells-commits)

Run all checks: pre-commit run --all-files

Manual Checks

Run these before installing changed skills:

./bin/check-skills
./bin/check-install
./bin/check-prose

Use docs/internal/testing/skill-test-matrix.md for manual Claude Code and OpenCode behavior checks. Treat auto-loading as a behavior to measure, not a deterministic contract.

Prose Linting

This repo uses Vale with tbhb/vale-ai-tells (pinned to v1.13.1 in .vale.ini) for deterministic checks on AI-writing patterns. Run vale sync once per checkout to download the pinned style packages into .vale/; downloaded package directories are ignored by git.

prose-lint prefers a project's own .vale.ini. If the target project has no Vale config, the skill uses its bundled fallback config. If Vale is not installed or vale sync fails, the skill reports that prose linting was skipped and does not try to install anything.

Use prose-lint for mechanical findings. Use humanizer after that when changed docs or outgoing prose need a rewrite.

Adding a Skill

  1. Create plugins/<plugin>/skills/<name>/SKILL.md with frontmatter (name, description)
  2. If new plugin: create plugins/<plugin>/.claude-plugin/plugin.json and add to .claude-plugin/marketplace.json
  3. Run ./bin/install-skills opencode or ./bin/install-skills codex if using those tools

Structure

claude-skills/
├── plugins/                     # Source of truth: one plugin per domain
│   ├── python/                  # python-quality, python-review
│   ├── rust/                    # rust-design, rust-async, rust-quality, rust-review, rust-modules
│   ├── docs/                    # docs-bustest, prose-lint, humanizer, mermaid
│   ├── workflow/                # plan-discipline, gate-probes, skill-retro
│   ├── vale-lsp/                # Vale LSP config (no skills)
│   └── haskell-lsp/             # Haskell LSP config (no skills)
├── .claude-plugin/
│   └── marketplace.json         # Marketplace registry
├── bin/
│   ├── install-skills           # Install to OpenCode + Codex
│   ├── check-skills             # Static skill/frontmatter checks
│   ├── check-install            # Temp-home install checks
│   └── check-prose              # Vale/prose lint smoke checks
├── docs/
│   └── internal/testing/        # Manual Claude/OpenCode test matrix
├── feedback/                    # Session retros (gitignored local working docs)
└── _archive/
    └── legacy-slash-commands/   # v1 slash commands (2025-11)

Archive

_archive/legacy-slash-commands/ contains v1 slash commands from before Claude Code had skills. Some have useful patterns worth mining; check before building from scratch.

Ver o original no GitHub

Bom para

Relacionados