Communitygithub.com

ComeOnOliver/skillshub

Diretrizes de desenvolvimento frontend para aplicações Next.js 15. Padrões modernos com React 19, TypeScript, Shadcn/ui e Tailwind CSS. Inclui Server Components, Client Components, App Router, estrutura de arquivos, componentes Shadcn/ui, otimização de desempenho e boas práticas TypeScript.

O que é skillshub?

Este skill fornece um guia abrangente e detalhado para desenvolvedores que trabalham com Next.js 15 e React 19, com foco em componentes modernos como Server Components e Client Components, o App Router do Next.js, e o ecossistema Shadcn/ui + Tailwind CSS. Ele define quando usar cada tipo de componente, como organizar arquivos de forma escalável, boas práticas para estilização, roteamento, busca e envio de dados, além de otimizações de desempenho como lazy loading e uso de Suspense. Inclui exemplos práticos de código, uma estrutura de pastas de referência e listas de verificação rápidas para criar novos componentes ou páginas. É útil para agentes de IA (como Claude Code, Cursor, Codex) que auxiliam no desenvolvimento frontend, garantindo consistência e adesão a padrões modernos de arquitetura React e Next.js.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/0chan-smc/frontend-dev-guidelines

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Diretrizes de Desenvolvimento Frontend

Propósito

Guia abrangente para o desenvolvimento moderno com Next.js 15 e React 19, enfatizando Server Components, Client Components, padrões do App Router, componentes Shadcn/ui, organização adequada de arquivos e otimização de desempenho.

Quando Usar Este Skill

  • Criar novos componentes ou páginas
  • Construir novas funcionalidades
  • Buscar dados (Server Components, Server Actions)
  • Configurar roteamento com Next.js App Router
  • Estilizar componentes com Tailwind CSS e Shadcn/ui
  • Otimização de desempenho
  • Organizar código frontend
  • Boas práticas TypeScript

Início Rápido

Lista de Verificação para Novo Componente

Criando um componente? Siga esta lista:

  • Determinar Server vs Client Component (padrão: Server Component)
  • Adicionar diretiva "use client" somente se necessário (interatividade, hooks, APIs do navegador)
  • Usar TypeScript com tipos de props explícitos
  • Importar componentes Shadcn/ui de @/components/ui
  • Usar classes Tailwind CSS para estilização
  • Usar aliases de importação: @/components, @/lib, @/hooks
  • Usar utilitário cn() para classes condicionais
  • Exportação padrão no final
  • Usar Server Components para busca de dados quando possível

Lista de Verificação para Nova Página

Criando uma página? Configure esta estrutura:

  • Criar app/{nome-da-rota}/page.tsx para a rota
  • Usar Server Component por padrão
  • Buscar dados diretamente no Server Component
  • Criar diretório components/ para componentes específicos da página
  • Usar loading.tsx para estados de carregamento
  • Usar error.tsx para limites de erro
  • Exportar metadados para SEO

Referência Rápida de Aliases de Importação

AliasResolve ParaExemplo
@/Raiz do projetoimport { cn } from '@/lib/utils'
@/componentscomponents/import { Button } from '@/components/ui/button'
@/liblib/import { cn } from '@/lib/utils'
@/hookshooks/import { useMobile } from '@/hooks/use-mobile'
@/appapp/import { Metadata } from 'next'

Definido em: configuração de paths em tsconfig.json


Folha de Dicas de Importações Comuns

// Next.js
import { Metadata } from 'next'
import { Suspense } from 'react'
import { notFound, redirect } from 'next/navigation'

// React (apenas Client Components)
;('use client')
import { useState, useCallback, useMemo } from 'react'

// Componentes Shadcn/ui
import { Button } from '@/components/ui/button'
import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'
import { Input } from '@/components/ui/input'

// Utilitários
import { cn } from '@/lib/utils'

// Hooks (apenas Client Components)
import { useMobile } from '@/hooks/use-mobile'

// Tipos
import type { ComponentProps } from 'react'

Guias por Tópico

🎨 Padrões de Componentes

Server Components vs Client Components:

  • Server Components (padrão): Sem "use client", podem buscar dados diretamente, bundle menor
  • Client Components: Adicione "use client" para interatividade, hooks, APIs do navegador

Conceitos-chave:

  • Padrão: Server Components
  • Use Client Components apenas quando necessário
  • Use componentes Shadcn/ui (já são Client Components)
  • Estrutura do componente: Props → Busca de Dados → Renderização → Exportação

Exemplo de Server Component:

// app/features/posts/components/PostList.tsx
import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'

interface PostListProps {
  posts: Post[]
}

export function PostList({ posts }: PostListProps) {
  return (
    <div className='grid gap-4'>
      {posts.map((post) => (
        <Card key={post.id}>
          <CardHeader>
            <CardTitle>{post.title}</CardTitle>
          </CardHeader>
          <CardContent>{post.content}</CardContent>
        </Card>
      ))}
    </div>
  )
}

Exemplo de Client Component:

// app/features/posts/components/PostForm.tsx
'use client'

import { useState } from 'react'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'

export function PostForm() {
  const [title, setTitle] = useState('')

  return (
    <form>
      <Input value={title} onChange={(e) => setTitle(e.target.value)} />
      <Button type='submit'>Enviar</Button>
    </form>
  )
}

📊 Busca de Dados

PADRÃO PRIMÁRIO: Server Components

  • Busque dados diretamente em Server Components
  • Use async/await em Server Components
  • Não precisa de useEffect ou bibliotecas de busca de dados
  • Deduplicação automática de requisições

Server Actions:

  • Use para mutações (formulários, atualizações)
  • Crie diretório app/actions/
  • Marque com diretiva "use server"

Exemplo de Server Component com Busca de Dados:

// app/posts/page.tsx
import { PostList } from '@/components/PostList'

async function getPosts() {
  const res = await fetch('https://api.example.com/posts', {
    cache: 'no-store', // ou 'force-cache', 'revalidate'
  })
  return res.json()
}

export default async function PostsPage() {
  const posts = await getPosts()

  return <PostList posts={posts} />
}

Exemplo de Server Action:

// app/actions/posts.ts
'use server'

export async function createPost(formData: FormData) {
  const title = formData.get('title')
  // ... lógica de validação e criação
  redirect('/posts')
}

📁 Organização de Arquivos

Estrutura do App Router:

app/
  (routes)/
    page.tsx          # Página da rota
    layout.tsx        # Layout da rota
    loading.tsx       # UI de carregamento
    error.tsx         # UI de erro
  components/         # Componentes compartilhados
    ui/               # Componentes Shadcn/ui
  features/           # Código específico de funcionalidades
    posts/
      components/     # Componentes da funcionalidade
      actions/        # Server Actions
      types/          # Tipos TypeScript
lib/
  utils.ts            # Utilitários (cn, etc.)
hooks/
  use-mobile.ts       # Hooks customizados (apenas Client)

Organização por Funcionalidade:

  • app/features/{funcionalidade}/: Páginas/rotas específicas da funcionalidade
  • components/: Componentes verdadeiramente reutilizáveis
  • components/ui/: Componentes Shadcn/ui (não modifique diretamente)

🎨 Estilização

Tailwind CSS + Shadcn/ui:

  • Use classes utilitárias do Tailwind
  • Use utilitário cn() para classes condicionais
  • Componentes Shadcn/ui usam variáveis CSS para temas
  • Personalize tema em app/globals.css

Padrões de Estilização:

import { cn } from '@/lib/utils'

interface ButtonProps {
  variant?: 'primary' | 'secondary'
  className?: string
}

export function Button({ variant = 'primary', className }: ButtonProps) {
  return (
    <button
      className={cn(
        'rounded-md px-4 py-2',
        variant === 'primary' && 'bg-primary text-primary-foreground',
        variant === 'secondary' && 'bg-secondary text-secondary-foreground',
        className,
      )}
    >
      Clique aqui
    </button>
  )
}

Componentes Shadcn/ui:

  • Importe de @/components/ui/{nome-do-componente}
  • Componentes já são estilizados e acessíveis
  • Personalize via prop className ou variáveis CSS

🛣️ Roteamento

Next.js App Router - Baseado em Arquivos:

  • Diretório: app/{nome-da-rota}/page.tsx
  • Rotas aninhadas: app/{pai}/{filho}/page.tsx
  • Rotas dinâmicas: app/posts/[id]/page.tsx
  • Grupos de rotas: app/(marketing)/about/page.tsx

Exemplo de Rota:

// app/posts/page.tsx
import { Metadata } from 'next'
import { PostList } from '@/components/PostList'

export const metadata: Metadata = {
  title: 'Posts',
  description: 'Lista de todos os posts',
}

export default async function PostsPage() {
  const posts = await getPosts()

  return (
    <div className='container mx-auto py-8'>
      <h1 className='text-3xl font-bold mb-6'>Posts</h1>
      <PostList posts={posts} />
    </div>
  )
}

Rota Dinâmica:

// app/posts/[id]/page.tsx
interface PostPageProps {
  params: Promise<{ id: string }>
}

export default async function PostPage({ params }: PostPageProps) {
  const { id } = await params
  const post = await getPost(id)

  if (!post) {
    notFound()
  }

  return <PostDetail post={post} />
}

⏳ Estados de Carregamento e Erro

Estados de Carregamento:

  • Crie loading.tsx no diretório da rota
  • Automaticamente encapsula a página em Suspense
  • Use para carregamento no nível da rota

Limites de Erro:

  • Crie error.tsx no diretório da rota
  • Automaticamente captura erros na rota
  • Pode redefinir o estado de erro

Exemplo de UI de Carregamento:

// app/posts/loading.tsx
export default function Loading() {
  return (
    <div className='flex items-center justify-center min-h-screen'>
      <div className='animate-spin rounded-full h-8 w-8 border-b-2 border-primary' />
    </div>
  )
}

Exemplo de UI de Erro:

// app/posts/error.tsx
'use client'

import { useEffect } from 'react'
import { Button } from '@/components/ui/button'

export default function Error({
  error,
  reset,
}: {
  error: Error & { digest?: string }
  reset: () => void
}) {
  useEffect(() => {
    console.error(error)
  }, [error])

  return (
    <div className='flex flex-col items-center justify-center min-h-screen'>
      <h2 className='text-2xl font-bold mb-4'>Algo deu errado!</h2>
      <Button onClick={reset}>Tentar novamente</Button>
    </div>
  )
}

⚡ Desempenho

Padrões de Otimização:

  • Use Server Components (bundle menor)
  • Use next/image para imagens
  • Use next/font para fontes
  • Carregue Client Components de forma lazy quando possível
  • Use useMemo e useCallback em Client Components
  • Transmita dados com limites de Suspense

Otimização de Imagens:

import Image from 'next/image'

export function Avatar({ src, alt }: { src: string; alt: string }) {
  return (
    <Image
      src={src}
      alt={alt}
      width={40}
      height={40}
      className='rounded-full'
    />
  )
}

Streaming com Suspense:

import { Suspense } from 'react'
import { PostList } from '@/components/PostList'
import { Loading } from '@/components/Loading'

export default function Page() {
  return (
    <div>
      <Suspense fallback={<Loading />}>
        <PostList />
      </Suspense>
    </div>
  )
}

📘 TypeScript

Padrões:

  • Modo estrito ativado
  • Sem tipo any
  • Tipos de retorno explícitos em funções
  • Importações de tipos: import type { Post } from '@/types/post'
  • Interfaces de props de componentes com JSDoc

Exemplo:

import type { ComponentProps } from 'react'
import { Button } from '@/components/ui/button'

/**
 * Componente de botão personalizado com estado de carregamento
 */
interface CustomButtonProps extends ComponentProps<typeof Button> {
  isLoading?: boolean
}

export function CustomButton({
  isLoading,
  children,
  ...props
}: CustomButtonProps) {
  return (
    <Button disabled={isLoading} {...props}>
      {isLoading ? 'Carregando...' : children}
    </Button>
  )
}

🔧 Padrões Comuns

Manipulação de Formulários:

  • Use Server Actions para envios de formulários
  • Use react-hook-form com zod para validação (Client Components)
  • Use componentes de Formulário Shadcn/ui

Exemplo de Formulário com Server Action:

// app/actions/posts.ts
'use server'

import { z } from 'zod'

const createPostSchema = z.object({
  title: z.string().min(1),
  content: z.string().min(1),
})

export async function createPost(formData: FormData) {
  const rawData = {
    title: formData.get('title'),
    content: formData.get('content'),
  }

  const validated = createPostSchema.parse(rawData)
  // ... lógica de criação do post
  redirect('/posts')
}

Metadados:

import { Metadata } from 'next'

export const metadata: Metadata = {
  title: 'Posts',
  description: 'Lista de todos os posts',
  openGraph: {
    title: 'Posts',
    description: 'Lista de todos os posts',
  },
}

Princípios Fundamentais

  1. Server Components Primeiro: Padrão: Server Components, use Client Components apenas quando necessário
  2. Estrutura do App Router: Use roteamento baseado em arquivos com diretório app/
  3. Componentes Shadcn/ui: Use componentes pré-construídos e acessíveis
  4. Tailwind CSS: Estilização utilitária com auxiliar cn()
  5. TypeScript Estrito: Sem any, tipos explícitos
  6. Desempenho: Use Server Components, otimize imagens, carregue de forma lazy quando necessário
  7. Organização de Arquivos: Funcionalidades em app/features/, compartilhados em components/
  8. Aliases de Importação: Use prefixo @/ para importações limpas

Referência Rápida: Estrutura de Arquivos

app/
  layout.tsx                    # Layout raiz
  page.tsx                      # Página inicial
  globals.css                   # Estilos globais
  (routes)/
    posts/
      page.tsx                  # Página de lista de posts
      [id]/
        page.tsx                # Página de detalhes do post
      loading.tsx               # UI de carregamento
      error.tsx                 # UI de erro
  features/
    posts/
      components/
        PostList.tsx            # Componentes da funcionalidade
      actions/
        posts.ts                # Server Actions
components/
  ui/                           # Componentes Shadcn/ui
    button.tsx
    card.tsx
lib/
  utils.ts                      # Utilitários (cn, etc.)
hooks/
  use-mobile.ts                 # Hooks customizados

Template de Componente Moderno (Cópia Rápida)

Server Component:

// app/components/PostCard.tsx
import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'
import type { Post } from '@/types/post'

interface PostCardProps {
  post: Post
}

export function PostCard({ post }: PostCardProps) {
  return (
    <Card>
      <CardHeader>
        <CardTitle>{post.title}</CardTitle>
      </CardHeader>
      <CardContent>
        <p>{post.content}</p>
      </CardContent>
    </Card>
  )
}

Client Component:

// app/components/PostForm.tsx
'use client'

import { useState } from 'react'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'

export function PostForm() {
  const [title, setTitle] = useState('')

  return (
    <form>
      <Input value={title} onChange={(e) => setTitle(e.target.value)} />
      <Button type='submit'>Enviar</Button>
    </form>
  )
}

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Next.js 16+ uses App Router with Server Components by default. Client Components are only used when interactivity is needed (hooks, event handlers, browser APIs).

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Habilidades Relacionadas