Communitygithub.com

ComeOnOliver/skillshub

Richtlinien für die Frontend-Entwicklung mit Next.js 15, React 19, TypeScript, Shadcn/ui und Tailwind CSS.

Was ist skillshub?

Dieses Skill bietet eine umfassende Anleitung für die moderne Frontend-Entwicklung mit Next.js 15 und React 19. Es deckt wesentliche Konzepte wie Server Components, Client Components, das App Router-Muster, Shadcn/ui-Komponenten, Dateiorganisation, Datenabruf, Styling und Leistungsoptimierung ab. Entwickler können es als Nachschlagewerk nutzen, um konsistente, leistungsstarke und wartbare Frontend-Codebasen zu erstellen. Es unterstützt die Plattformen von Claude Code, Cursor und Codex und definiert klare Pattern, Importkonventionen und Best Practices, um häufige Fehler zu vermeiden und den Entwicklungsprozess zu beschleunigen.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Richtlinien für die Frontend-Entwicklung

Zweck

Umfassender Leitfaden für die moderne Entwicklung mit Next.js 15 und React 19 mit Fokus auf Server Components, Client Components, App Router-Muster, Shadcn/ui-Komponenten, richtige Dateiorganisation und Leistungsoptimierung.

Wann dieses Skill verwendet werden sollte

  • Erstellen neuer Komponenten oder Seiten
  • Entwickeln neuer Funktionen
  • Abrufen von Daten (Server Components, Server Actions)
  • Einrichten des Routings mit dem Next.js App Router
  • Stylen von Komponenten mit Tailwind CSS und Shadcn/ui
  • Leistungsoptimierung
  • Organisieren von Frontend-Code
  • TypeScript-Best-Practices

Schnellstart

Checkliste für neue Komponenten

Beim Erstellen einer Komponente dieser Checkliste folgen:

  • Entscheiden zwischen Server- und Client-Komponente (Standard: Server-Komponente)
  • "use client"-Direktive nur bei Bedarf hinzufügen (Interaktivität, Hooks, Browser-APIs)
  • TypeScript mit expliziten Prop-Typen verwenden
  • Shadcn/ui-Komponenten aus @/components/ui importieren
  • Tailwind CSS-Klassen zum Stylen verwenden
  • Import-Aliase verwenden: @/components, @/lib, @/hooks
  • cn()-Utility für bedingte Klassen verwenden
  • Standard-Export am Ende
  • Nach Möglichkeit Server-Komponenten für den Datenabruf verwenden

Checkliste für neue Seiten

Beim Erstellen einer Seite diese Struktur einrichten:

  • app/{route-name}/page.tsx für die Route erstellen
  • Standardmäßig Server-Komponente verwenden
  • Daten direkt in der Server-Komponente abrufen
  • components/-Verzeichnis für seiten-spezifische Komponenten erstellen
  • loading.tsx für Ladezustände verwenden
  • error.tsx für Fehlergrenzen verwenden
  • Metadaten für SEO exportieren

Import-Aliase Kurzreferenz

AliasLöst aufBeispiel
@/Projektstammimport { 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'

Definiert in: tsconfig.json-Pfadkonfiguration


Spickzettel für häufige Importe

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

// React (nur Client-Komponenten)
;("use client")
import { useState, useCallback, useMemo } from 'react'

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

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

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

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

Themenführungen

🎨 Komponentenmuster

Server-Komponenten vs. Client-Komponenten:

  • Server-Komponenten (Standard): Kein "use client", können Daten direkt abrufen, kleineres Bundle
  • Client-Komponenten: Fügen Sie "use client" für Interaktivität, Hooks, Browser-APIs hinzu

Schlüsselkonzepte:

  • Standardmäßig Server-Komponenten verwenden
  • Client-Komponenten nur bei Bedarf einsetzen
  • Shadcn/ui-Komponenten nutzen (bereits Client-Komponenten)
  • Komponentenstruktur: Props → Datenabruf → Rendern → Export

Beispiel einer Server-Komponente:

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

Beispiel einer Client-Komponente:

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

📊 Datenabruf

PRIMÄRES MUSTER: Server-Komponenten

  • Daten direkt in Server-Komponenten abrufen
  • async/await in Server-Komponenten verwenden
  • Kein Bedarf an useEffect oder Datenabruf-Bibliotheken
  • Automatische Anforderungsdeduplizierung

Server-Aktionen:

  • Für Mutationen (Formulare, Aktualisierungen) verwenden
  • app/actions/-Verzeichnis erstellen
  • Mit "use server"-Direktive markieren

Beispiel einer Server-Komponente mit Datenabruf:

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

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

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

  return <PostList posts={posts} />
}

Beispiel einer Server-Aktion:

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

export async function createPost(formData: FormData) {
  const title = formData.get('title')
  // ... Validierungs- und Erstellungslogik
  redirect('/posts')
}

📁 Dateiorganisation

App Router-Struktur:

app/
  (routes)/
    page.tsx          # Routenseite
    layout.tsx        # Routenlayout
    loading.tsx       # Lade-UI
    error.tsx         # Fehler-UI
  components/         # Gemeinsame Komponenten
    ui/               # Shadcn/ui-Komponenten
  features/           # Funktionsspezifischer Code
    posts/
      components/     # Funktionskomponenten
      actions/        # Server-Aktionen
      types/          # TypeScript-Typen
lib/
  utils.ts            # Werkzeuge (cn, usw.)
hooks/
  use-mobile.ts       # Benutzerdefinierte Hooks (nur Client)

Funktionsorganisation:

  • app/features/{feature}/: Funktionsspezifische Seiten/Routen
  • components/: Wiederverwendbare Komponenten
  • components/ui/: Shadcn/ui-Komponenten (nicht direkt ändern)

🎨 Styling

Tailwind CSS + Shadcn/ui:

  • Tailwind-Utility-Klassen verwenden
  • cn()-Utility für bedingte Klassen verwenden
  • Shadcn/ui-Komponenten verwenden CSS-Variablen für das Theming
  • Theme in app/globals.css anpassen

Styling-Muster:

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,
      )}
    >
      Klick mich
    </button>
  )
}

Shadcn/ui-Komponenten:

  • Aus @/components/ui/{component-name} importieren
  • Komponenten sind bereits gestylt und barrierefrei
  • Anpassung über className-Prop oder CSS-Variablen

🛣️ Routing

Next.js App Router - Dateibasiert:

  • Verzeichnis: app/{route-name}/page.tsx
  • Verschachtelte Routen: app/{parent}/{child}/page.tsx
  • Dynamische Routen: app/posts/[id]/page.tsx
  • Routengruppen: app/(marketing)/about/page.tsx

Beispiel einer Route:

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

export const metadata: Metadata = {
  title: 'Beiträge',
  description: 'Liste aller Beiträge',
}

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

Dynamische Route:

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

⏳ Lade- und Fehlerzustände

Ladezustände:

  • loading.tsx im Routenverzeichnis erstellen
  • Umhüllt die Seite automatisch mit Suspense
  • Für routenweites Laden verwenden

Fehlergrenzen:

  • error.tsx im Routenverzeichnis erstellen
  • Fängt Fehler in der Route automatisch ab
  • Kann den Fehlerzustand zurücksetzen

Beispiel einer Lade-UI:

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

Beispiel einer Fehler-UI:

// 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'>Etwas ist schiefgelaufen!</h2>
      <Button onClick={reset}>Erneut versuchen</Button>
    </div>
  )
}

⚡ Leistung

Optimierungsmuster:

  • Server-Komponenten verwenden (kleineres Bundle)
  • next/image für Bilder verwenden
  • next/font für Schriftarten verwenden
  • Client-Komponenten nach Möglichkeit lazy laden
  • useMemo und useCallback in Client-Komponenten verwenden
  • Daten mit Suspense-Grenzen streamen

Bildoptimierung:

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

Standards:

  • Strenger Modus aktiviert
  • Kein any-Typ
  • Explizite Rückgabetypen bei Funktionen
  • Typ-Importe: import type { Post } from '@/types/post'
  • Komponenten-Prop-Schnittstellen mit JSDoc

Beispiel:

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

/**
 * Benutzerdefinierte Schaltflächenkomponente mit Ladezustand
 */
interface CustomButtonProps extends ComponentProps<typeof Button> {
  isLoading?: boolean
}

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

🔧 Häufige Muster

Formularverarbeitung:

  • Server-Aktionen für Formulareinreichungen verwenden
  • react-hook-form mit zod für Validierung (Client-Komponenten) verwenden
  • Shadcn/ui-Formularkomponenten verwenden

Beispiel eines Formulars mit Server-Aktion:

// 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)
  // ... Beitragserstellungslogik
  redirect('/posts')
}

Metadaten:

import { Metadata } from 'next'

export const metadata: Metadata = {
  title: 'Beiträge',
  description: 'Liste aller Beiträge',
  openGraph: {
    title: 'Beiträge',
    description: 'Liste aller Beiträge',
  },
}

Kernprinzipien

  1. Server-Komponenten zuerst: Standardmäßig Server-Komponenten verwenden, Client-Komponenten nur bei Bedarf einsetzen
  2. App Router-Struktur: Dateibasiertes Routing mit app/-Verzeichnis verwenden
  3. Shadcn/ui-Komponenten: Vorgefertigte barrierefreie Komponenten verwenden
  4. Tailwind CSS: Utility-first Styling mit cn()-Hilfsfunktion
  5. TypeScript Streng: Kein any, explizite Typen
  6. Leistung: Server-Komponenten verwenden, Bilder optimieren, bei Bedarf lazy laden
  7. Dateiorganisation: Funktionen in app/features/, Gemeinsames in components/
  8. Import-Aliase: @/-Präfix für saubere Importe verwenden

Kurzreferenz: Dateistruktur

app/
  layout.tsx                    # Stamm-Layout
  page.tsx                      # Startseite
  globals.css                   # Globale Styles
  (routes)/
    posts/
      page.tsx                  # Beitragslistenseite
      [id]/
        page.tsx                # Beitragsdetailseite
      loading.tsx               # Lade-UI
      error.tsx                 # Fehler-UI
  features/
    posts/
      components/
        PostList.tsx            # Funktionskomponenten
      actions/
        posts.ts                # Server-Aktionen
components/
  ui/                           # Shadcn/ui-Komponenten
    button.tsx
    card.tsx
lib/
  utils.ts                      # Werkzeuge (cn, usw.)
hooks/
  use-mobile.ts                 # Benutzerdefinierte Hooks

Moderne Komponentenvorlage (Schnellkopie)

Server-Komponente:

// 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-Komponente:

// 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>
      <div>
        <Input value={title} onChange={(e) => setTitle(e.target.value)} />
      </div>
      <Button type='submit'>Absenden</Button>
    </form>
  )
}

Abschluss

Diese Richtlinien stellen sicher, dass der Frontend-Code konsistent, wartbar und leistungsstark ist. Wenn Sie diese Muster befolgen, erstellen Sie skalierbare Anwendungen mit modernen Next.js- und React-Praktiken gemäß den Branchenstandards.

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

Verwandte Skills