convez.ai
SkillDesenvolvimento WebIntermediário
VelimirMueller

Claude Development Skills — Frontend

VelimirMueller/claude_development_skills

Julgamento sênior executável para frontends escaláveis e mantíveis

Ver no GitHub
BomPluginScore · de 0 a 100

Conjunto de 33 skills executáveis para Claude que externalizam o julgamento técnico sênior em frontend. Audita o código existente e aplica apenas o que falta, com suporte dual React 19/Vue 3, idempotente e livre de templates congelados. Cobre scaffold, state management, testes, routing e boas práticas consolidadas.

Instalação

$npx convez-ai VelimirMueller/claude_development_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
7
Forks
1
Acompanhando
0
Saúde
57%
Último commit
há 1 semana
Versão
v0.8.0
Issues abertas
3
Contribuidores
1

Casos de uso

  • Auditar e padronizar projetos frontend existentes sem reiniciar
  • Scaffold projetos novos com arquitetura battle-tested (React 19 ou Vue 3)
  • Implementar state management correto (Query + Zustand/Pinia) com seams tipados
  • Configurar testing, error tracking e realtime com isolamento de dependências
  • Externalizar padrões sênior de um time para execução automática e consistente

Veredito

Projeto ambicioso que traduz experiência sênior em procedures auditáveis e idempotentes. Forte em princípios arquiteturais (seams, boundaries, server/UI state) e cobertura prática (React 19/Vue 3, TanStack Query/Router, Vitest/Playwright). Depende de CLI bem integrada ao Claude para real impact; a qualidade técnica é sólida, mas o ROI depende da adesão do time.

README

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

frontendskills

Senior frontend judgment — externalized as Claude Code skills that execute.

Not a template that freezes a snapshot of "best practice," but a set of audit-first procedures that inspect what's already in front of them and apply only the senior move that's missing. Dual-framework React 19 / Vue 3, every version-specific claim checked against 2026's live tooling.

33 skills · Vite-SPA app lifecycle + landing + workflow catalogues · React 19 / Vue 3 · MIT


The idea

Every senior carries a body of judgment that rarely gets written down — where server state ends and UI state begins, why an auth token must never touch localStorage, what a "molecule" is and isn't. It usually lives in one head and leaves when they do.

frontendskills takes that judgment out of the head and makes it executable — on demand, on any codebase, the same way every time. Three properties make it a tool rather than a template:

  • Audit-first & idempotent. Each skill inspects what's already there and applies only the missing move. Point it at an empty directory and it scaffolds; point it at a three-year-old repo and it brings one concern up to standard; run it twice and the second run is a no-op.
  • Seams, not scattered vendor calls. fetcher, captureError, env, queryKeys, the analytics and flag clients — one point of indirection each, so swapping a vendor or mocking a test is a one-file change.
  • Boundaries that make bugs unrepresentable. Server data lives in the Query cache, never a store; tokens never touch localStorage. The worst recurring bugs are designed out, not patched.

Every rule ships with its when to deviate. The aim is judgment, not dogma.

The catalogue

Bootstrap & tooling

  • scaffold-frontend-project — Vite + TS app (React 19 / Vue 3), pnpm via Corepack, Node LTS, Tailwind v4.
  • clean-frontend-scaffolding — strip the Vite demo down to a clean slate.
  • configure-typescript — strict plus the modern flags, and the @/ alias everywhere.
  • validate-env — Zod-validate import.meta.env at boot; one typed env the seams import.
  • configure-linting — Biome (lint + import sort) + Prettier (format) + a lefthook pre-commit.
  • set-up-frontend-structure — atomic-design folders and barrels; tests in tests/ by type.
  • create-module — the everyday authoring move: route new logic to the right layer (util/lib/hook/store) behind a typed boundary, keeping UI components thin.

State, data & resilience

  • set-up-state-management — TanStack Query (server) beside Zustand/Pinia (UI), one hard boundary, a typed query-key factory, a fetcher seam.
  • set-up-realtime — a transport-agnostic WebSocket seam that writes live server-push straight into the Query cache (patch the entity, invalidate the lists, re-sync on reconnect); connection status as the only UI store.
  • set-up-error-boundaries — layered boundaries behind a pluggable captureError seam.
  • configure-error-tracking — wire that seam to Sentry: tracing, masked replay, hidden source maps.

Testing

  • configure-test-stack — Vitest (Node + real-browser), Storybook stories-as-tests, Playwright e2e, and MSW mocking the network, under tests/{unit,ui,integration,e2e}.

Capabilities

  • set-up-routing — TanStack Router / Vue Router: typed routes, lazy splitting, loader↔Query prefetch, guards.
  • set-up-forms — React Hook Form / VeeValidate + Zod: one schema is shape, rules, and types; submit → mutation.
  • set-up-auth — the current user as server state, no localStorage tokens, route guards, single-flight 401 refresh.
  • set-up-i18n — i18next / vue-i18n: typed keys, lazy locales, Intl for every format.
  • set-up-document-head — per-route title/meta/OG and a truthful <html lang> (a11y + SEO).
  • set-up-feature-flags — a vendor-agnostic OpenFeature seam, fail-closed defaults, targeting, flag-gated routes.

Experience

  • set-up-design-system — Tailwind v4 @theme tokens, class-based dark mode applied before first paint, cva primitives.
  • configure-accessibility — a11y lint, semantic/focus/reduced-motion conventions, axe in tests.
  • optimize-performance — the React Compiler, route/code-splitting, a CI bundle budget, Core Web Vitals.

Polish

  • set-up-motion — native View Transitions + the Motion library, every animation reduced-motion-gated.
  • set-up-pwa — a vite-plugin-pwa offline shell, installable, with optional query-cache persistence.
  • configure-analytics — a provider-agnostic, privacy-first analytics seam + Web Vitals RUM.

Shipping & security

  • configure-ci — a GitHub Actions gate (lint → typecheck → test → build → e2e + bundle budget) and Netlify preview deploys per PR.
  • set-up-security-headers — a Content-Security-Policy and security headers via Netlify, dependency hygiene (Dependabot), and the real XSS surface.

Landing & content pages (framework-agnostic)

  • build-landing-page — one job per page, the section grammar (hero → proof → benefits → pricing → FAQ → final CTA), a semantic skeleton, and a hero LCP/CLS budget.
  • set-up-seo — the crawlability gate (content in served HTML), per-page metadata, JSON-LD by page type, sitemap + robots, answer-engine-readable structure.
  • set-up-lead-capture — the destination seam, invisible-first spam defenses (honeypot, time-trap → Turnstile), consent at capture, double opt-in.
  • audit-content-quality — rubric-driven page scoring with quoted evidence; fixes only the failed criteria. Project rubric at .claude/rubrics/content-quality.md overrides the default.
  • audit-copy-compliance — the pre-publish copy gate: violations with quoted text, the rule broken, and a compliant rewrite. Project rules at .claude/rubrics/copy-compliance.md.

These five audit built HTML (any stack — Next, Astro, Nuxt, prerendered Vite, plain HTML) and gate themselves on the page-level question in skills/landing/_shared/page-types.md: must this page be readable without JS?

Workflow: commits & pull requests (framework-agnostic)

  • write-commit-messages — a subject and body any developer from junior to CTO can read and act on.
  • write-pull-requests — a bug-fix or feature description reviewers from junior to CTO can follow end to end.

Both write to one contract, skills/workflow/_shared/audience.md: the junior can follow the text without tribal knowledge, the senior finds every claim next to its evidence, the CTO gets outcome and risk in the first lines.

How it composes

The skills interlock front-to-back. A greenfield project runs roughly:

scaffold → clean → configure-typescript → validate-env → configure-linting →
set-up-frontend-structure → set-up-state-management → set-up-error-boundaries →
configure-test-stack → set-up-routing → set-up-forms → set-up-auth → … → experience & polish

The router carries the queryClient in its context, so a route loader prefetches into the exact cache a component's hook reads; the auth guard reads that same context; the form's submit invalidates that same query key; realtime writes into it from a socket. Because every skill is audit-first, this is a guide, not a constraint — run any one against an existing project to bring just that concern up to standard.

Install

For local Claude Code use. Add this directory as a marketplace path in your Claude Code settings; Claude Code auto-discovers every skills/**/SKILL.md. A skill announces when it's relevant — "Use when adding state management…" — and loads only then, so the knowledge costs nothing until the moment it's needed.

Validate

bash scripts/validate.sh

Checks that the manifest parses, every SKILL.md carries a name and a Use when… description, and every relative reference link resolves.

Further reading

Status

v0.5.0. Three catalogues, one philosophy. skills/frontend/ covers the full Vite-SPA app lifecycle — bootstrap → language & tooling → structure → state → testing → capabilities → experience → polish → shipping — in 26 composable skills. skills/landing/ adds the public-page world in 5 framework-agnostic skills: composition, discoverability, lead capture, and two rubric-driven audits whose rules a project can override. skills/workflow/ adds delivery in 2 framework-agnostic skills: commit messages and pull-request descriptions written for the junior, the senior, and the CTO at once. Deeper infrastructure and backend domains will follow under the same plugin.

License

MIT © 2026 Velimir Müller.

Ver o original no GitHub

Bom para

Relacionados