Claude Skills
vinayagrw/claude-skills
Skills para Claude Code que geram diagramas, SVGs animados e docs técnicas
Ver no GitHubColeção curada de skills para Claude Code que transforma ideias em artefatos polidos e editáveis: diagramas, SVGs animados, Markdown estruturado e documentos de design. Inclui 6 skills especializadas em criação visual e redação técnica com validadores próprios.
Instalação
npx convez-ai vinayagrw/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
- Gerar diagramas arquiteturais editáveis em draw.io
- Criar SVGs animados para banners, loaders e gráficos
- Estruturar READMEs e documentação Markdown com estilo
- Escrever Technical Design Records com raciocínio de decisão
- Fazer esboços visuais em Excalidraw
- Explorar soluções arquiteturais com pesquisa estruturada
Veredito

Conjunto bem pensado de skills para Claude Code com foco em saída visual e documentação técnica. Cada skill é opinionada, auto-contida e traz validadores; integra-se naturalmente ao fluxo de Claude sem exigir prompts manuais.
README
A tradução para o português deste README ainda está na fila.
🧰 Claude Skills
A curated collection of Claude Code skills that turn a one-line idea — or a dense design doc — into polished, editable artifacts: diagrams that explain themselves, SVGs that actually move, beautiful Markdown, and review-ready design records.
The skills · Quick start · Install · How it works · Contributing
[!TIP] New here? Jump to Quick start to install everything in two commands — then just talk to Claude Code normally. Each skill triggers itself when it's relevant.
Every skill in here follows the same philosophy: read for the intention first, then make the form carry the meaning — and verify with evidence before claiming it's done (each one ships its own validator script). They're not prompt snippets; they're small, opinionated playbooks with reference docs and tooling.
flowchart LR
subgraph Visuals["🎨 Make something visual"]
A["drawio-creative-diagrams"]
B["excalidraw-creative-diagrams"]
C["creative-animated-svg"]
end
subgraph Docs["📝 Make something written"]
D["markdown-craft"]
E["tdr-author"]
F["solution-design-explorer"]
end
idea(["an idea, a spec,<br/>or a doc"]) --> Visuals
idea --> Docs
✨ The skills
| Skill | What it gives you | Reach for it when… |
|---|---|---|
| 📝 markdown-craft | Beautiful, platform-aware Markdown — hero headers, badges, > [!NOTE] callouts, <details>, Mermaid, dark/light logos | "write a README for X", "make this doc look good on GitHub", any .md you want to not look like a wall of text |
| 🎬 creative-animated-svg | SVGs that genuinely move — self-drawing line art, flow-along-path, morphs, gooey/turbulence filters, loaders, hero graphics | "animate this", an SVG logo/loader/banner, a draw-on diagram, a scroll-reveal |
| 📐 drawio-creative-diagrams | Polished, fully-editable draw.io .drawio files — gradient lanes, semantic colour, animated flow edges, HTML-table nodes | "diagram this architecture", "turn this spec into a picture", anything you'll keep editing in diagrams.net |
| ✏️ excalidraw-creative-diagrams | Hand-drawn Excalidraw .excalidraw scenes — sketchy charm, sticky-notes, frames, switchable sketch/clean mode, draw-on animation | "sketch this", "whiteboard this idea", a wireframe, a hand-drawn figure |
| 📋 tdr-author | Decision-first Technical Design Records — rationale, rejected alternatives, gap audit, Confluence-paste-safe ASCII | "write up the design for X", "document this decision", "a spec the team can review" |
| 🧭 solution-design-explorer | Deep, research-backed solution-architecture deep-dives — surveys how the field solves it, multi-persona reasoning, pattern comparison, self red-team, SOTA refresh, a recommendation | "architect a solution for X", "how does the industry do this?", "find the top N approaches and recommend one" |
[!NOTE] Each skill is self-contained: a
SKILL.mdplaybook, areferences/folder of deep-dive docs, and ascripts/validator that proves the output is correct before you ship it.
🚀 Quick start
Install all six skills into your personal Claude Code skills folder, then start (or restart) Claude Code — they load automatically.
git clone https://github.com/vinayagrw/claude-skills.git
mkdir -p ~/.claude/skills
cp -r claude-skills/*/ ~/.claude/skills/
git clone https://github.com/vinayagrw/claude-skills.git
New-Item -ItemType Directory -Force "$HOME\.claude\skills" | Out-Null
Get-ChildItem claude-skills -Directory |
Copy-Item -Destination "$HOME\.claude\skills" -Recurse -Force
That's it. Ask Claude Code to "diagram this", "animate this SVG", or "write a README for
this project" and the matching skill kicks in. You can also invoke one explicitly by typing
/markdown-craft (or any skill name).
📦 Installation
Where skills live
Claude Code discovers skills from two places — pick based on who should get them:
flowchart LR
R["📦 this repo"] -->|copy a folder| P["~/.claude/skills/"]
R -->|or copy into a project| J[".claude/skills/ (in a repo)"]
P --> C["available in<br/><b>all</b> your projects"]
J --> D["available in<br/><b>that</b> project only"]
[!NOTE] On Windows,
~/.claude/skillsis%USERPROFILE%\.claude\skills(e.g.C:\Users\you\.claude\skills).
Install just one skill
Grab only what you want — every skill is a single self-contained folder.
git clone https://github.com/vinayagrw/claude-skills.git
cp -r claude-skills/markdown-craft ~/.claude/skills/ # swap in any skill name
git clone --depth 1 --filter=blob:none --sparse https://github.com/vinayagrw/claude-skills.git
cd claude-skills
git sparse-checkout set markdown-craft
cp -r markdown-craft ~/.claude/skills/
Install into a single project
Want a skill only inside one repo (and shared with your team via version control)? Copy it
into that project's .claude/skills/ instead of your home folder:
mkdir -p .claude/skills
cp -r path/to/claude-skills/drawio-creative-diagrams .claude/skills/
Update later
cd claude-skills && git pull
cp -r ./*/ ~/.claude/skills/ # re-copy the folders you use
🧭 How skills work
A skill is a folder Claude Code reads on demand. Each one has:
SKILL.md— the playbook, with YAML frontmatter whosedescriptiontells Claude when to use the skill. That description is the trigger: Claude reads it and reaches for the skill on its own when your request matches — even if you never name it.references/— deeper docs loaded only when needed (so the base instructions stay lean).scripts/— runnable tooling, e.g. each skill's validator that checks the output is correct before Claude reports back.
Two ways a skill fires:
- 🤖 Automatically — Claude matches your intent against the skill descriptions. Ask to
"make a flowchart of this" and
drawio-creative-diagramsengages. - ⌨️ Explicitly — type
/skill-name(e.g./tdr-author) to invoke it directly.
[!TIP] Not sure a skill loaded? Just ask Claude "which skills do you have available?" — installed skills show up in its skill list once they're in
~/.claude/skills/.
🔍 Skill details
Authors READMEs, guides, changelogs, and docs that use the full range of GitHub-Flavored
Markdown instead of flat prose. It starts by naming the document archetype (README vs
guide vs reference vs comparison) and laying down that shape, then leans on the right
features — centered hero, shields.io badges, alert callouts, collapsibles, Mermaid, aligned
tables, dark/light <picture> logos.
Its signature insight is "know your renderer": GitHub, GitLab, npm/PyPI, and plain
CommonMark support different feature subsets, so the skill picks features the target can
actually render (and degrades gracefully when it can't). Ships scripts/lint_markdown.py,
which checks heading hierarchy, broken links/images, unresolved ToC anchors, malformed
alerts, unbalanced <details>/fences, and table columns. (This very README was written with it.)
Try: "write a README for my project" · "format these notes into a guide" · "make this doc look good on GitHub"
Builds genuinely animated SVGs: self-drawing line art, flow-along-a-path motion, shape
morphs, gooey/turbulence filters, animated gradients, looping ambient backgrounds, charts,
glow/shimmer, loaders and hero graphics. Covers both a standalone .svg that plays the
moment it opens (CSS @keyframes + SMIL + filters) and SVG-in-HTML for the full arsenal
(scroll-driven, Web Animations API, GSAP/Lottie).
Teaches the latest CSS (@property, motion path, scroll-driven timelines, color-mix), the
rendering-context rules that decide whether a file actually animates (an SVG used as an
<img> freezes to a static frame!), accessibility (prefers-reduced-motion) and 60fps
performance. Ships scripts/validate_svg.py.
Try: "animate this logo" · "an SVG loading spinner" · "make this diagram draw itself on"
Turns any input — a design doc, spec, API flow, or one-liner — into a .drawio file that a
staff engineer would happily paste into a review. Goes beyond boxes-and-arrows with
gradient-filled lanes, a semantic colour system, swimlane grouping, meaning-bearing edge
styles (control vs data vs identity paths), embedded HTML-table nodes, animated flow
edges, and legends. Can also embed Mermaid or generate from CSV.
Starts from the intention — it picks a metaphor that performs the idea (a pipeline becomes
a rail with checkpoints; a bypass is drawn physically going around the system). Ships
scripts/validate_drawio.py.
Try: "diagram this architecture" · "turn this spec into a picture" · "visualise this API flow"
Produces .excalidraw scenes with real hand-drawn charm: sketchy roughness, Excalifont
lettering, hachure fills, the curated Excalidraw palette, sticky-note clusters, titled
frames, bound labels and arrows, and freedraw highlighter accents. Switchable sketch
(loose brainstorm) vs clean (tidy deliverable) house style, plus draw-on / keyframe
animation, elbow arrows, frames-as-slides, and the Mermaid-to-Excalidraw path.
Every binding is validated so labels stick to boxes and arrows follow shapes on the first
import. Ships scripts/validate_excalidraw.py.
Try: "sketch this on a whiteboard" · "wireframe this screen" · "make an excalidraw of this idea"
Authors Technical Design Records: decision-first design docs that record a choice with its rationale and rejected alternatives, grounded in the actual codebase (it reads the real types/handlers before writing any contract), with an implementation gap audit and concrete sub-specs for the blockers. Produces dual output — a Mermaid master that renders on GitHub and a Confluence-paste-safe ASCII copy — and lints the latter for paste safety.
Try: "write a TDR for choosing X over Y" · "document this decision for the team" · "turn this into a design doc"
Produces the kind of design deliverable you'd put in front of a review board or a client: it surveys how the community actually solves the problem, reasons through it with multiple expert personas, proposes an architecture with Mermaid diagrams, compares the viable design patterns in a matrix, red-teams its own approach to surface gaps, then refreshes against the last ~2 months of state of the art before landing a clear recommendation with honest scope.
It works from a fixed document skeleton and a research playbook, so the output is rigorous
rather than a vibe — and an optional pre-sales close makes the "why us" explicit when the
audience is client-facing. Ships scripts/validate_mermaid.py to render-check every diagram.
Try: "architect a solution for X" · "how does the industry approach this?" · "find the top approaches and recommend one"
🤝 Contributing
Got a skill worth sharing? PRs welcome.
- Create a folder
your-skill-name/with aSKILL.mdat its root. - Give the frontmatter a crisp, slightly-pushy
description— it's what makes Claude trigger the skill at the right time. - Put deep-dive docs in
references/and any tooling inscripts/. - Include a validator and a "verify before you claim it's done" step — the house rule here is evidence over assertion.
- Open a pull request describing what the skill does and when it should fire.
See any existing skill (e.g. markdown-craft/) as a template.
📝 License
Released under the Apache License 2.0.