Claude Skills - Biblioteca de Skills para Desenvolvimento
Shearerbeard/claude-skills
Skills compostas para qualidade, review e design de código + docs
Ver no GitHubColeçã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-skills1 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
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
| Skill | Plugin | Trigger | Purpose |
|---|---|---|---|
python-quality | python | writing .py | Toolchain (uv/ruff) + code patterns + LLM anti-patterns |
python-review | python | reviewing Python | 7 Python-specific gate probes |
rust-quality | rust | writing .rs | Anti-pattern catch list (clone escapes, wildcards, transitive deps) |
rust-async | rust | async, tokio, Send+Sync | Cooperative scheduling, Send+'static, spawn_blocking vs rayon, async Drop |
rust-design | rust | writing/designing/reviewing types | ADT-first workflow, constrained types, railway programming, 6-step clone avoidance |
rust-review | rust | reviewing Rust | 7 Rust-specific gate probes |
rust-modules | rust | Rust module layout | Modern file layout, re-exports, type co-location |
docs-bustest | docs | docs review / updates | 24-item bus test for documentation quality |
prose-lint | docs | Vale / prose lint | Deterministic AI-tell checks for docs and emitted prose |
humanizer | docs | publishable prose | Remove AI writing patterns from user-facing text |
mermaid | docs | .mmd files / diagrams | Render and open Mermaid diagrams |
plan-discipline | workflow | planning / design / scope | Verification-first, scope interview, blast radius |
gate-probes | workflow | commit / review / PR | 7 universal quality probes + surgical discipline |
skill-retro | workflow | "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:
| Gate | Who | What |
|---|---|---|
| S Self-review | Agent | Run deterministic tools (lint, fmt, type check, build, test). Fix all failures. |
| A Agent second opinion | Context-isolated subagent | Review diff with fresh eyes. No prior implementation context. Find issues or sign off. |
| M Manual testing | Agent | Exercise the feature, report behavior, verify success criteria. |
| U User review | User | Pause and present diffs + findings. Highlight highest-risk changes. Await approval. |
| T User testing | User | Prescribe 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
- Create
plugins/<plugin>/skills/<name>/SKILL.mdwith frontmatter (name,description) - If new plugin: create
plugins/<plugin>/.claude-plugin/plugin.jsonand add to.claude-plugin/marketplace.json - Run
./bin/install-skills opencodeor./bin/install-skills codexif 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.