Communitygithub.com

ComeOnOliver/skillshub

Guide de développement frontend pour applications Next.js 15. Modèles modernes avec React 19, TypeScript, Shadcn/ui, Tailwind CSS. Inclut les Server Components, Client Components, App Router, structure de fichiers, composants Shadcn/ui, optimisation des performances et bonnes pratiques TypeScript.

Qu'est-ce que skillshub ?

Ce skill fournit un guide complet pour le développement frontend moderne avec Next.js 15 et React 19, en mettant l'accent sur les Server Components, les Client Components et les modèles App Router. Il est particulièrement utile pour les développeurs travaillant avec Shadcn/ui, Tailwind CSS et TypeScript, en offrant des checklists rapides pour la création de composants et de pages, ainsi que des exemples concrets de code. Le skill couvre des sujets essentiels comme la récupération de données avec les Server Components, les actions serveur pour les mutations, l'optimisation des performances avec le streaming et Suspense, et une organisation claire des fichiers. Il supporte des environnements de développement basés sur Next.js 15, et est conçu pour être utilisé comme référence rapide lors du développement frontend, en s'intégrant parfaitement aux outils comme Claude Code, Cursor ou Codex.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Guide de Développement Frontend

Objectif

Guide complet pour le développement moderne avec Next.js 15 et React 19, en mettant l'accent sur les Server Components, les Client Components, les modèles App Router, les composants Shadcn/ui, l'organisation appropriée des fichiers et l'optimisation des performances.

Quand utiliser ce skill

  • Création de nouveaux composants ou pages
  • Développement de nouvelles fonctionnalités
  • Récupération de données (Server Components, Server Actions)
  • Configuration du routage avec Next.js App Router
  • Stylisation des composants avec Tailwind CSS et Shadcn/ui
  • Optimisation des performances
  • Organisation du code frontend
  • Bonnes pratiques TypeScript

Démarrage rapide

Liste de vérification pour un nouveau composant

Vous créez un composant ? Suivez cette checklist :

  • Déterminer Server vs Client Component (par défaut : Server Component)
  • Ajouter la directive "use client" uniquement si nécessaire (interactivité, hooks, API navigateur)
  • Utiliser TypeScript avec des types de props explicites
  • Importer les composants Shadcn/ui depuis @/components/ui
  • Utiliser les classes Tailwind CSS pour le style
  • Utiliser les alias d'import : @/components, @/lib, @/hooks
  • Utiliser l'utilitaire cn() pour les classes conditionnelles
  • Export par défaut en bas
  • Utiliser les Server Components pour la récupération de données lorsque c'est possible

Liste de vérification pour une nouvelle page

Vous créez une page ? Configurez cette structure :

  • Créer app/{nom-de-route}/page.tsx pour la route
  • Utiliser un Server Component par défaut
  • Récupérer les données directement dans le Server Component
  • Créer un répertoire components/ pour les composants spécifiques à la page
  • Utiliser loading.tsx pour les états de chargement
  • Utiliser error.tsx pour les limites d'erreur
  • Exporter les métadonnées pour le SEO

Référence rapide des alias d'import

AliasRésout versExemple
@/Racine du projetimport { 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'

Défini dans : configuration paths de tsconfig.json


Aide-mémoire des imports courants

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

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

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

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

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

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

Guides thématiques

🎨 Modèles de composants

Server Components vs Client Components :

  • Server Components (par défaut) : Pas de "use client", peuvent récupérer les données directement, bundle plus petit
  • Client Components : Ajouter "use client" pour l'interactivité, les hooks, les API navigateur

Concepts clés :

  • Par défaut, utiliser les Server Components
  • Utiliser les Client Components uniquement lorsque nécessaire
  • Utiliser les composants Shadcn/ui (déjà des Client Components)
  • Structure du composant : Props → Récupération de données → Rendu → Export

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

Exemple 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'>Soumettre</Button>
    </form>
  )
}

📊 Récupération de données

MODÈLE PRINCIPAL : Server Components

  • Récupérer les données directement dans les Server Components
  • Utiliser async/await dans les Server Components
  • Pas besoin de useEffect ni de bibliothèques de récupération de données
  • Déduplication automatique des requêtes

Server Actions :

  • Utiliser pour les mutations (formulaires, mises à jour)
  • Créer un répertoire app/actions/
  • Marquer avec la directive "use server"

Exemple de Server Component avec récupération de données :

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

Exemple de Server Action :

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

export async function createPost(formData: FormData) {
  const title = formData.get('title')
  // ... logique de validation et de création
  redirect('/posts')
}

📁 Organisation des fichiers

Structure App Router :

app/
  (routes)/
    page.tsx          # Page de route
    layout.tsx        # Mise en page de route
    loading.tsx       # Interface de chargement
    error.tsx         # Interface d'erreur
  components/         # Composants partagés
    ui/               # Composants Shadcn/ui
  features/           # Code spécifique aux fonctionnalités
    posts/
      components/     # Composants de la fonctionnalité
      actions/        # Server Actions
      types/          # Types TypeScript
lib/
  utils.ts            # Utilitaires (cn, etc.)
hooks/
  use-mobile.ts       # Hooks personnalisés (Client uniquement)

Organisation par fonctionnalité :

  • app/features/{fonctionnalité}/ : Pages/routes spécifiques à une fonctionnalité
  • components/ : Composants véritablement réutilisables
  • components/ui/ : Composants Shadcn/ui (ne pas modifier directement)

🎨 Stylisation

Tailwind CSS + Shadcn/ui :

  • Utiliser les classes utilitaires Tailwind
  • Utiliser l'utilitaire cn() pour les classes conditionnelles
  • Les composants Shadcn/ui utilisent des variables CSS pour le thème
  • Personnaliser le thème dans app/globals.css

Modèles de stylisation :

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,
      )}
    >
      Cliquez-moi
    </button>
  )
}

Composants Shadcn/ui :

  • Importer depuis @/components/ui/{nom-du-composant}
  • Les composants sont déjà stylisés et accessibles
  • Personnaliser via la prop className ou les variables CSS

🛣️ Routage

Next.js App Router - Basé sur les fichiers :

  • Répertoire : app/{nom-de-route}/page.tsx
  • Routes imbriquées : app/{parent}/{enfant}/page.tsx
  • Routes dynamiques : app/posts/[id]/page.tsx
  • Groupes de routes : app/(marketing)/about/page.tsx

Exemple de route :

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

export const metadata: Metadata = {
  title: 'Articles',
  description: 'Liste de tous les articles',
}

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'>Articles</h1>
      <PostList posts={posts} />
    </div>
  )
}

Route dynamique :

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

⏳ États de chargement et d'erreur

États de chargement :

  • Créer loading.tsx dans le répertoire de la route
  • Enveloppe automatiquement la page dans Suspense
  • Utiliser pour le chargement au niveau de la route

Limites d'erreur :

  • Créer error.tsx dans le répertoire de la route
  • Attrape automatiquement les erreurs dans la route
  • Peut réinitialiser l'état d'erreur

Exemple d'interface de chargement :

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

Exemple d'interface d'erreur :

// 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'>Quelque chose a mal tourné !</h2>
      <Button onClick={reset}>Réessayer</Button>
    </div>
  )
}

⚡ Performances

Modèles d'optimisation :

  • Utiliser les Server Components (bundle plus petit)
  • Utiliser next/image pour les images
  • Utiliser next/font pour les polices
  • Charger paresseusement les Client Components lorsque c'est possible
  • Utiliser useMemo et useCallback dans les Client Components
  • Streamer les données avec les limites Suspense

Optimisation des images :

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 avec 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

Normes :

  • Mode strict activé
  • Pas de type any
  • Types de retour explicites sur les fonctions
  • Imports de types : import type { Post } from '@/types/post'
  • Interfaces de props de composant avec JSDoc

Exemple :

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

/**
 * Composant bouton personnalisé avec état de chargement
 */
interface CustomButtonProps extends ComponentProps<typeof Button> {
  isLoading?: boolean
}

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

🔧 Modèles courants

Gestion des formulaires :

  • Utiliser les Server Actions pour les soumissions de formulaires
  • Utiliser react-hook-form avec zod pour la validation (Client Components)
  • Utiliser les composants Formulaire de Shadcn/ui

Exemple de formulaire avec 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)
  // ... logique de création de l'article
  redirect('/posts')
}

Métadonnées :

import { Metadata } from 'next'

export const metadata: Metadata = {
  title: 'Articles',
  description: 'Liste de tous les articles',
  openGraph: {
    title: 'Articles',
    description: 'Liste de tous les articles',
  },
}

Principes fondamentaux

  1. Server Components en premier : Par défaut, utiliser les Server Components, utiliser les Client Components uniquement lorsque nécessaire
  2. Structure App Router : Utiliser le routage basé sur les fichiers avec le répertoire app/
  3. Composants Shadcn/ui : Utiliser des composants accessibles pré-construits
  4. Tailwind CSS : Stylisation utilitaire avec l'aide de cn()
  5. TypeScript strict : Pas de any, types explicites
  6. Performances : Utiliser les Server Components, optimiser les images, charger paresseusement lorsque nécessaire
  7. Organisation des fichiers : Fonctionnalités dans app/features/, partagées dans components/
  8. Alias d'import : Utiliser le préfixe @/ pour des imports propres

Référence rapide : Structure des fichiers

app/
  layout.tsx                    # Mise en page racine
  page.tsx                      # Page d'accueil
  globals.css                   # Styles globaux
  (routes)/
    posts/
      page.tsx                  # Page de liste des articles
      [id]/
        page.tsx                # Page de détail d'un article
      loading.tsx               # Interface de chargement
      error.tsx                 # Interface d'erreur
  features/
    posts/
      components/
        PostList.tsx            # Composants de la fonctionnalité
      actions/
        posts.ts                # Server Actions
components/
  ui/                           # Composants Shadcn/ui
    button.tsx
    card.tsx
lib/
  utils.ts                      # Utilitaires (cn, etc.)
hooks/
  use-mobile.ts                 # Hooks personnalisés

Modèle de composant moderne (Copie rapide)

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'>Soumettre</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

Skills associés