Communitygithub.com

ComeOnOliver/skillshub

Guía de desarrollo frontend para aplicaciones Next.js 15 con React 19, TypeScript, Shadcn/ui y Tailwind CSS. Incluye patrones modernos con Server Components, Client Components, App Router, estructura de archivos, componentes Shadcn/ui, optimización de rendimiento y mejores prácticas de TypeScript.

¿Qué es skillshub?

Este skill proporciona una guía completa y detallada para desarrolladores que trabajan con Next.js 15, React 19, TypeScript, Shadcn/ui y Tailwind CSS. Está diseñado para ayudar a crear componentes, páginas y funcionalidades siguiendo las mejores prácticas modernas, priorizando Server Components sobre Client Components para mejorar el rendimiento y reduciendo el tamaño del bundle. Incluye diagramas de estructura de archivos, ejemplos de código para componentes de servidor y cliente, patrones de obtención de datos (Server Components y Server Actions), manejo de rutas con App Router, estilos utilitarios con Tailwind CSS y la función `cn()`, así como optimización de rendimiento mediante `next/image`, `next/font`, `Suspense` y lazy loading de componentes cliente. Es ideal para cualquier flujo de trabajo de desarrollo frontend con el stack Next.js + React.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Guía de Desarrollo Frontend

Propósito

Guía completa para el desarrollo moderno con Next.js 15 y React 19, que enfatiza Server Components, Client Components, patrones de App Router, componentes Shadcn/ui, organización de archivos adecuada y optimización del rendimiento.

Cuándo Usar Este Skill

  • Crear nuevos componentes o páginas
  • Construir nuevas funcionalidades
  • Obtener datos (Server Components, Server Actions)
  • Configurar rutas con Next.js App Router
  • Dar estilo a componentes con Tailwind CSS y Shadcn/ui
  • Optimizar el rendimiento
  • Organizar código frontend
  • Mejores prácticas de TypeScript

Inicio Rápido

Lista de Verificación para Nuevo Componente

¿Creando un componente? Sigue esta lista:

  • Determinar si es Server vs Client Component (por defecto: Server Component)
  • Añadir directiva "use client" solo si es necesario (interactividad, hooks, APIs del navegador)
  • Usar TypeScript con tipos explícitos en props
  • Importar componentes Shadcn/ui desde @/components/ui
  • Usar clases de Tailwind CSS para estilos
  • Usar alias de importación: @/components, @/lib, @/hooks
  • Usar la utilidad cn() para clases condicionales
  • Exportar por defecto al final
  • Usar Server Components para la obtención de datos siempre que sea posible

Lista de Verificación para Nueva Página

¿Creando una página? Configura esta estructura:

  • Crear app/{nombre-de-ruta}/page.tsx para la ruta
  • Usar Server Component por defecto
  • Obtener datos directamente en el Server Component
  • Crear directorio components/ para componentes específicos de la página
  • Usar loading.tsx para estados de carga
  • Usar error.tsx para límites de error
  • Exportar metadatos para SEO

Referencia Rápida de Alias de Importación

AliasResuelve aEjemplo
@/Raíz del proyectoimport { 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 en: configuración de paths en tsconfig.json


Chuleta de Importaciones Comunes

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

// React (solo 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'

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

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

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

Guías por Tema

🎨 Patrones de Componentes

Server Components vs Client Components:

  • Server Components (por defecto): Sin "use client", pueden obtener datos directamente, bundle más pequeño
  • Client Components: Añadir "use client" para interactividad, hooks, APIs del navegador

Conceptos Clave:

  • Por defecto usar Server Components
  • Solo usar Client Components cuando sea necesario
  • Usar componentes Shadcn/ui (ya son Client Components)
  • Estructura del componente: Props → Obtención de datos → Renderizado → Exportación

Ejemplo 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>
  )
}

Ejemplo 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>
  )
}

📊 Obtención de Datos

PATRÓN PRINCIPAL: Server Components

  • Obtener datos directamente en Server Components
  • Usar async/await en Server Components
  • No es necesario usar useEffect ni bibliotecas de obtención de datos
  • Deduplicación automática de solicitudes

Server Actions:

  • Usar para mutaciones (formularios, actualizaciones)
  • Crear directorio app/actions/
  • Marcar con directiva "use server"

Ejemplo de Server Component con Obtención de Datos:

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

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

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

  return <PostList posts={posts} />
}

Ejemplo de Server Action:

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

export async function createPost(formData: FormData) {
  const title = formData.get('title')
  // ... lógica de validación y creación
  redirect('/posts')
}

📁 Organización de Archivos

Estructura de App Router:

app/
  (rutas)/
    page.tsx          # Página de ruta
    layout.tsx        # Layout de ruta
    loading.tsx       # UI de carga
    error.tsx         # UI de error
  components/         # Componentes compartidos
    ui/               # Componentes Shadcn/ui
  features/           # Código específico de funcionalidad
    posts/
      components/     # Componentes de funcionalidad
      actions/        # Server Actions
      types/          # Tipos TypeScript
lib/
  utils.ts            # Utilidades (cn, etc.)
hooks/
  use-mobile.ts       # Hooks personalizados (solo cliente)

Organización por Funcionalidad:

  • app/features/{funcionalidad}/: Páginas/rutas específicas de funcionalidad
  • components/: Componentes verdaderamente reutilizables
  • components/ui/: Componentes Shadcn/ui (no modificar directamente)

🎨 Estilos

Tailwind CSS + Shadcn/ui:

  • Usar clases utilitarias de Tailwind
  • Usar la utilidad cn() para clases condicionales
  • Los componentes Shadcn/ui usan variables CSS para temas
  • Personalizar tema en app/globals.css

Patrones de Estilo:

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,
      )}
    >
      Click me
    </button>
  )
}

Componentes Shadcn/ui:

  • Importar desde @/components/ui/{nombre-del-componente}
  • Los componentes ya están estilizados y son accesibles
  • Personalizar mediante la prop className o variables CSS

🛣️ Rutas

Next.js App Router - Basado en Archivos:

  • Directorio: app/{nombre-de-ruta}/page.tsx
  • Rutas anidadas: app/{padre}/{hijo}/page.tsx
  • Rutas dinámicas: app/posts/[id]/page.tsx
  • Grupos de rutas: app/(marketing)/about/page.tsx

Ejemplo de Ruta:

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

export const metadata: Metadata = {
  title: 'Posts',
  description: 'Lista de todos los 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>
  )
}

Ruta 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 Carga y Error

Estados de Carga:

  • Crear loading.tsx en el directorio de la ruta
  • Automáticamente envuelve la página en Suspense
  • Usar para carga a nivel de ruta

Límites de Error:

  • Crear error.tsx en el directorio de la ruta
  • Captura automáticamente errores en la ruta
  • Puede restablecer el estado de error

Ejemplo de UI de Carga:

// 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>
  )
}

Ejemplo de UI de Error:

// 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 salió mal!</h2>
      <Button onClick={reset}>Intentar de nuevo</Button>
    </div>
  )
}

⚡ Rendimiento

Patrones de Optimización:

  • Usar Server Components (bundle más pequeño)
  • Usar next/image para imágenes
  • Usar next/font para fuentes
  • Cargar Client Components de forma diferida cuando sea posible
  • Usar useMemo y useCallback en Client Components
  • Transmitir datos con límites de Suspense

Optimización de Imágenes:

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'
    />
  )
}

Transmisión con 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

Estándares:

  • Modo estricto activado
  • Sin tipo any
  • Tipos de retorno explícitos en funciones
  • Importaciones de tipos: import type { Post } from '@/types/post'
  • Interfaces de props de componentes con JSDoc

Ejemplo:

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

/**
 * Componente de botón personalizado con estado de carga
 */
interface CustomButtonProps extends ComponentProps<typeof Button> {
  isLoading?: boolean
}

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

🔧 Patrones Comunes

Manejo de Formularios:

  • Usar Server Actions para envíos de formularios
  • Usar react-hook-form con zod para validación (Client Components)
  • Usar componentes de formulario de Shadcn/ui

Ejemplo de Formulario con 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 creación del post
  redirect('/posts')
}

Metadatos:

import { Metadata } from 'next'

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

Principios Fundamentales

  1. Server Components Primero: Por defecto usar Server Components, usar Client Components solo cuando sea necesario
  2. Estructura de App Router: Usar enrutamiento basado en archivos con el directorio app/
  3. Componentes Shadcn/ui: Usar componentes preconstruidos y accesibles
  4. Tailwind CSS: Estilo utilitario con el helper cn()
  5. TypeScript Estricto: Sin any, tipos explícitos
  6. Rendimiento: Usar Server Components, optimizar imágenes, cargar de forma diferida cuando sea necesario
  7. Organización de Archivos: Funcionalidades en app/features/, compartidos en components/
  8. Alias de Importación: Usar el prefijo @/ para importaciones limpias

Referencia Rápida: Estructura de Archivos

app/
  layout.tsx                    # Layout raíz
  page.tsx                      # Página de inicio
  globals.css                   # Estilos globales
  (rutas)/
    posts/
      page.tsx                  # Página de lista de posts
      [id]/
        page.tsx                # Página de detalle de post
      loading.tsx               # UI de carga
      error.tsx                 # UI de error
  features/
    posts/
      components/
        PostList.tsx            # Componentes de funcionalidad
      actions/
        posts.ts                # Server Actions
components/
  ui/                           # Componentes Shadcn/ui
    button.tsx
    card.tsx
lib/
  utils.ts                      # Utilidades (cn, etc.)
hooks/
  use-mobile.ts                 # Hooks personalizados

Plantilla de Componente Moderno (Copia 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>
  )
}

Mejores Prácticas Generales

  1. Priorizar Server Components para reducir el tamaño del bundle del lado del cliente.
  2. Usar Server Actions para la lógica de mutación en lugar de manejadores de eventos del lado del cliente.
  3. Organizar por funcionalidad (app/features/) en lugar de por tipo técnico.
  4. Mantener los componentes pequeños y enfocados en una única responsabilidad.
  5. Usar los componentes Shadcn/ui como base y personalizar con la prop className o variables CSS.
  6. Añadir estados de carga y error a cada página usando loading.tsx y error.tsx.
  7. Exportar metadatos para cada página para mejorar SEO.
  8. Usar TypeScript con tipos estrictos y sin tipo any.
  9. Usar la utilidad cn() para combinar clases de Tailwind CSS condicionalmente.
  10. Aprovechar next/image para la optimización automática de imágenes.

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

Skills relacionados