convez.ai
SkillDesenvolvimento WebIntermediário
criscandv

CDV Skills - Coleção de Skills para Claude Code

criscandv/cdv-skills

Skills reutilizáveis para Claude Code: Django, React, Python, Astro, Tailwind

Ver no GitHub
InicialPluginScore · de 0 a 100

Repositório de skills personalizadas para Claude Code, organizadas por tecnologia (Django, React, Python, Tailwind, etc.). Cada skill encapsula workflows, convenções e padrões de domínio específico, instalável via toolkit do Vercel. Cobre backend, frontend, ferramentas e automação de projeto.

Instalação

$npx convez-ai criscandv/cdv-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
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
2

Casos de uso

  • Scaffolding de APIs Django com convenções pré-definidas
  • Padrões de desenvolvimento React/Next.js e TanStack Router
  • Automação de workflows Git e documentação de projeto
  • Convenções de teste, ORM, REST API e DevTools Python

Veredito

Coleção bem estruturada de skills reutilizáveis para Claude Code focada em stack full-stack moderno (Django + React). Útil para equipes que querem padronizar workflows e acelerar scaffolding, mas requer já estar usando Claude Code e o toolkit do Vercel.

README

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

cdv-skills

Personal collection of Claude Code skills, grouped by technology.

Skills extend Claude with custom workflows and domain knowledge. Each skill lives in its own directory with a SKILL.md containing metadata (frontmatter) and instructions.

Installation

Install every skill in this repo with Vercel's npx skills toolkit:

npx skills add https://github.com/criscandv/cdv-skills.git

That walks the repo, finds every directory with a SKILL.md, and registers it. Re-run the command after a git pull to pick up updates.

Structure

cdv-skills/
├── README.md
├── django/                  # Django + DRF backend conventions and actions
│   ├── django-conventions/
│   ├── django-orm-patterns/
│   ├── django-rest-framework/
│   ├── django-cbv-patterns/
│   ├── django-testing/
│   ├── django-new-api/
│   ├── django-feature/
│   └── django-normalize/
├── python/                  # Python ecosystem (uv, ruff, pre-commit, pytest)
│   └── python-tooling/
├── frontend-core/           # Framework-agnostic JS / TS / testing conventions
│   ├── frontend-conventions/
│   ├── frontend-data-layer/
│   ├── frontend-testing/
│   ├── frontend-normalize/
│   └── typescript-patterns/
├── react/                   # React ecosystem (React + Next.js + Vite SPA + TanStack Router)
│   ├── react-patterns/
│   ├── react-spa/
│   ├── nextjs-patterns/
│   └── tanstack-router/
├── astro/                   # Astro framework
│   └── astro/
├── tailwind/                # Tailwind CSS
│   └── tailwindcss-v4/
├── http/                    # HTTP / network requests
│   └── fetch/
├── design/                  # Design and content
│   ├── ui-ux/
│   └── copywriting/
└── workflow/                # Git, agent meta-files, project documentation
    ├── gpush/
    ├── agent-instructions/
    └── project-docs/

Categories with a single skill (astro/astro/, tailwind/tailwindcss-v4/, etc.) are deliberate placeholders — new skills for the same technology drop into the same folder without reorganising the repo.

Skills

django/ — Django + DRF backend

SkillDescription
django-conventionsThe Django rulebook: UUID PKs, soft-delete BaseModel, abstracts/ folders, owner FK, custom pagination, dual auth, mandatory admin/tests/API docs.
django-orm-patternsModels layer: abstract bases, managers, soft-delete, UUID, owner FK, queries, transactions/savepoints, safe migrations.
django-rest-frameworkSerialization + API infra: serializers, validation, JWT + API-key auth, permissions, custom pagination, domain exceptions + global handler, consistent response renderer, drf-spectacular.
django-cbv-patternsView layer: ViewSet vs APIView vs generics, base classes, @action with url_path.
django-testingpytest + factory-boy, fixtures, the TDD loop, what to assert per layer.
django-new-api/django-new-api — scaffold a new Django + DRF API from scratch with the full baseline wired.
django-feature/django-feature — add a complete vertical slice (model + admin + serializer + view + urls + tests + migration), test-first.
django-normalize/django-normalize — audit an existing project against the conventions and apply fixes incrementally and safely.

python/ — Python ecosystem

SkillDescription
python-toolinguv, ruff, pre-commit, pytest, pyproject.toml. Language tooling, not Django-specific.

frontend-core/ — JS / TS / testing conventions

SkillDescription
frontend-conventionsThe frontend rulebook: named exports, function vs arrow, kebab-case, no casting, type over interface, @/ alias, no drive-by refactors.
typescript-patternstype vs interface, type-only imports, unions over enums, guards over casts, keyof typeof, ComponentProps/PropsWithChildren.
frontend-data-layerReact Query (server state) vs Zustand (UI state), single Axios instance + interceptors, SSE streaming, auth/session, mitt events.
frontend-testingvitest + Testing Library + jsdom + user-event + MSW, colocated tests, query by role/label, mock HTTP at the network.
frontend-normalize/frontend-normalize — audit an existing JS/TS/React frontend (Vite/Next/CRA) and normalize incrementally.

react/ — React ecosystem

SkillDescription
react-patternsReact 19 components/hooks, "you might not need an Effect", effect deps, useMemo/useCallback discipline, refs as props, keys, state shape.
react-spaVite + React SPA setup (no Next.js): @/* alias in both tsconfig.json AND vite.config.ts, typed import.meta.env.VITE_*, project structure (src/features, src/routes, src/components/ui, src/lib), main.tsx + index.html essentials.
nextjs-patternsNext.js App Router: route groups, server vs client components, route handlers, NEXT_PUBLIC_ env vars, dynamic imports for SSR-unsafe libs, metadata.
tanstack-routerType-safe SPA router: file-based routing with the Vite plugin, createFileRoute, search params validated with Zod, route loaders integrated with React Query, beforeLoad auth guards, type-safe <Link>/useNavigate. Always consults Context7 before answering.

astro/ — Astro framework

SkillDescription
astroAstro expert: pages, components, layouts, content collections, islands (client:*), SSR adapters, View Transitions, astro:assets. Always consults Context7 before answering and ensures the @/* alias is configured.

tailwind/ — Tailwind CSS

SkillDescription
tailwindcss-v4Tailwind v4 expert: CSS-first config via @theme, custom utilities/variants, container queries, OKLCH colours, v3 → v4 migration. Always consults Context7 before answering — v4's API moved significantly.

http/ — Network requests

SkillDescription
fetchHTTP requests with the Web Fetch API: request shape, status-vs-network errors, AbortController for timeouts/cancellation, retries with exponential backoff, auth headers, server vs client context, standard response envelope, TypeScript at the boundary.

design/ — Design and content

SkillDescription
ui-uxDesign expert for screens with no mockup — hierarchy, palette (OKLCH + WCAG AA), type scale, 4/8-pt spacing, layout patterns, states, accessibility, design tokens that flow into Tailwind.
copywritingMicrocopy expert: CTAs, errors, empty states, headlines, onboarding. Writes in the language of the surrounding interface; picks voice/tone; avoids filler and faux-friendly chatter.

workflow/ — Git, agent meta-files, project docs

SkillSlash commandDescription
gpush/gpushStages changes, writes a Conventional Commits message (with type heuristics, BREAKING CHANGE support, monorepo scope, footers and pre-commit hook re-stage), pushes the current branch, offers PR or merge to base.
agent-instructions/agent-instructionsCreate or update a repo's AGENTS.md (canonical router into docs/) and CLAUDE.md (thin pointer + Claude-specific directives).
project-docs/project-docsCreate or update a project's docs/ set (ARCHITECTURE, WORKFLOW, COMMANDS, DESIGN, ONBOARDING) by interviewing the user. Language- and framework-agnostic.

External skills — installed per-project, not via this repo

Some skills are maintained outside this repo and installed per-project via their own tooling. They are not part of npx skills add and have to be set up wherever they're used. They live here as a documented list, not as code.

shadcn — the official shadcn/ui Claude Code skill

shadcn ships its own Claude Code skill bundled with assets, CLI references and rule files. The shadcn team maintains it and updates it as the library evolves. Install it per project (typically via the shadcn CLI — check the shadcn docs for the current install command); don't vendor it in this repo — the upstream version is the source of truth, and copying it here would freeze you at one commit.

After installing it in a project that also uses this suite, append the following block at the end of the installed SKILL.md so the skill points to the surrounding decisions covered here. Drop any bullet whose skill isn't installed in that specific project — pointers to absent skills are noise.

## Related skills in this project

shadcn lives on top of a stack and a framework. These sibling skills cover the surrounding decisions so this skill doesn't have to. **They are pointers, not dependencies** — `npx shadcn@latest info` already exposes the `framework`, `tailwindVersion`, `isRSC`, `packageManager`, etc. of the current project; reach for the matching skill only when the surrounding decision actually requires it.

- **`ui-ux`** — visual design upstream of any token: hierarchy, OKLCH palette with WCAG AA contrast, type and spacing scales, state coverage (loading/empty/error). Decide *what* the tokens should be here; encode them in Tailwind's `@theme` (see below); shadcn reads them through CSS variables.
- **`tailwindcss-v4`** — the theming layer underneath: `@theme` block, custom utilities and variants, dark mode wiring, animation tokens, container queries. Always consults Context7 before assuming v4 syntax.
- **`react-spa`** — when `framework` from `info` is **not** Next (typically Vite + React + TanStack Router): the `@/*` alias on both `tsconfig.json` and `vite.config.ts`, typed `import.meta.env.VITE_*`, the SPA `src/` layout that `src/components/ui/` plugs into, `main.tsx` essentials.
- **`nextjs-patterns`** — when `framework` from `info` is `next` (App Router): when to add `"use client"` (`isRSC: true` from project info), route handlers, `NEXT_PUBLIC_*` env vars, dynamic imports for SSR-unsafe libs, metadata. shadcn components that use state/effects/handlers/browser APIs need the directive in Next; this skill covers the rules around it.

For routing in a Vite SPA specifically, also see **`tanstack-router`** (file-based routing, type-safe `<Link>`, search params with Zod) — relevant when laying out pages that compose shadcn components into routes.

Adding a new skill

  1. Pick the category folder where the skill belongs (or create a new one if no existing category fits).
  2. Create a new directory inside it: mkdir <category>/my-skill.
  3. Add SKILL.md with frontmatter (name, description, optional disable-model-invocation) and instructions. Keep SKILL.md under ~500 lines; move long reference material into separate files.
  4. Optional: a scripts/ subfolder for executable helpers, an assets/ subfolder for templates.
  5. Commit and push. After your next git pull, re-run npx skills add https://github.com/criscandv/cdv-skills.git on every machine to pick up the new skill.

License

Personal use. Not licensed for redistribution.

Ver o original no GitHub

Bom para

Relacionados