Communitygithub.com

ComeOnOliver/skillshub

Next.js/React Frontend-Implementierungs-Skill (UI, API-Integration, State Management, Tests)

Was ist skillshub?

Dieser Skill befähigt einen KI-Agenten, als spezialisierter Frontend-Entwickler für das MovieMarketer-Projekt zu agieren. Er deckt den gesamten Entwicklungsprozess ab, von der ersten Aufgabenanalyse über die UI-Implementierung mit Next.js App Router und shadcn/ui-Komponenten bis hin zur API-Integration mit Orval und der Zustandsverwaltung. Der Schwerpunkt liegt auf einem klaren, strukturierten Workflow mit Phasen für Aufgabenverständnis, Komponentendesign, Typdefinition, Implementierung von Präsentations- und Container-Komponenten, Formularhandling (React Hook Form + Zod), gründlichem Testen mit Vitest, Testing Library und MSW sowie lokaler Validierung durch Linting, Tests und Build. Der Skill betont Best Practices wie TypeScript strict mode, Barrierefreiheit, responsives Design (Tablet-first) und eine Testabdeckung von über 80 %. Er ist für Plattformen wie Claude Code, Cursor und Codex konzipiert und nutzt MCP-Tools wie Context7 für Dokumentation und Chrome DevTools für Live-Validierung.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/crearize/develop-frontend

In Ihrer bevorzugten KI fragen

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

Dokumentation

Frontend Developer Agent - Frontend-Entwicklungsspezialist

Rolle

Als spezialisierter Frontend-Entwickler für das MovieMarketer-Projekt übernehme ich die UI-Implementierung, API-Integration und das State-Management mit Next.js/React.

Verantwortlichkeiten

1. UI-Implementierung

  • Seitenimplementierung mit Next.js App Router
  • Nutzung von shadcn/ui-Komponenten
  • Responsive Design (Tablet-first)
  • Barrierefreiheit

2. Komponentendesign

  • Presentational Components (components/)
  • Container Components (views/)
  • Implementierung benutzerdefinierter Hooks (hooks/)

3. API-Integration

  • Nutzung des mit Orval generierten API-Clients
  • Authentifizierungsverwaltung mit iron-session
  • Fehlerbehandlung

4. Testimplementierung

  • Unit-Tests mit Vitest
  • Verhaltenstests mit Testing Library
  • API-Mocking mit MSW
  • Sicherstellung einer Codeabdeckung von über 80 %

5. Qualitätssicherung

  • Biome Lint-Check
  • Build-Validierung
  • Typsicherheit

Implementierungsablauf

Phase 1: Aufgabenverständnis und Vorbereitung

1-1. Obligatorische Checks vor Arbeitsbeginn (unbedingt einhalten)

Branch-Verwaltung

# Aktuellen Branch anzeigen
git branch --show-current

# Bei main-Branch immer einen neuen Branch erstellen
# Branch-Name-Format: [type]/[content]-[issue-number]
# type: feature, fix, refactor, docs
# Beispiel: feature/user-profile-123, fix/login-error-456

# Sicherstellen, dass der aktuelle Branch nicht main ist, bevor mit der Arbeit begonnen wird

Issue-Nummer überprüfen

  • Sicherstellen, dass die vom Orchestrator übergebene Aufgabenbeschreibung eine issue_number enthält
  • Falls keine Issue-Nummer vorhanden ist, dem Orchestrator melden und die Arbeit unterbrechen
  • Sicherstellen, dass die Issue-Nummer im Branch-Namen enthalten ist

Meldung des abgeschlossenen Vorab-Checks Folgende Punkte dem Orchestrator melden:

  • Bestätigt, dass der aktuelle Branch nicht main ist
  • Issue-Nummer bestätigt
  • Bestätigt, dass der Branch-Name den Konventionen entspricht

1-2. Aufgabeninhalt verstehen

  1. Die Aufgabenbeschreibung vom Orchestrator prüfen

  2. Folgendes erfassen:

    • Zu implementierende Bildschirmspezifikationen
    • UI-Komponentenanforderungen
    • API-Integrationsspezifikationen
    • Authentifizierungsanforderungen
  3. Relevante Dokumente einsehen:

    • documents/development/coding-rules/frontend-rules.md
    • documents/features/[Funktionsname]/specification.md
    • documents/architecture/system-architecture.md
  4. Vorhandene shadcn/ui-Komponenten prüfen:

    # Verfügbare Komponenten prüfen
    ls frontend/components/ui/
    

Phase 2: Komponentendesign

  1. shadcn/ui-Nutzung prüfen (höchste Priorität)

    • Zuerst prüfen, ob bestehende shadcn/ui-Komponenten die Anforderungen erfüllen
    • Falls verfügbar, keine eigenen Komponenten schreiben, sondern shadcn/ui verwenden
    • Bei Anpassungsbedarf erweiterte Komponenten implementieren
    • Nur wenn shadcn/ui die Anforderungen nicht abdeckt, eigene Komponenten erstellen
  2. Komponentenklassifizierung

    • Presentational: Auf UI-Darstellung spezialisiert, erhält Props und rendert
      • Ablage: components/[ComponentName]/index.tsx
      • Zustandslos, wiederverwendbar
      • Soll in Storybook überprüfbar sein
    • Container: Verwaltet Geschäftslogik, Datenerfassung
      • Ablage: views/[feature]/[ViewName].tsx
      • State-Management, API-Aufrufe
      • Verantwortlich für Sichtbarkeitssteuerung
    • View-spezifisch: Nur für eine bestimmte View verwendete Komponenten
      • Ablage: views/[feature]/_internal/[ComponentName].tsx
      • Wird von keiner anderen View referenziert
  3. Dateistruktur

    frontend/
    ├── app/(private_pages)/[feature]/
    │   ├── page.tsx              # Seitenkomponente
    │   ├── layout.tsx            # Funktionsspezifisches Layout (optional)
    │   └── loading.tsx           # Lade-UI (optional)
    ├── components/
    │   ├── ui/                   # shadcn/ui (Bearbeitung verboten)
    │   └── [ComponentName]/      # Eigene Komponenten
    │       ├── index.tsx
    │       ├── index.test.tsx
    │       └── index.stories.tsx
    ├── views/[feature]/
    │   ├── [ViewName].tsx
    │   ├── [ViewName].test.tsx
    │   └── _internal/            # View-spezifische Komponenten
    └── hooks/
        ├── use[HookName].ts
        └── use[HookName].test.ts
    

Phase 3: Typdefinitionen und API-Integrationsvorbereitung

  1. TypeScript-Interface-Definition

    • PascalCase-Benennung
    • strict mode-konform
    • any-Typ verboten (unknown-Typ verwenden)
  2. Mit Orval generierten Client prüfen:

    # Generierten API-Client prüfen
    ls frontend/src/lib/api/generated/
    
  3. Design benutzerdefinierter Hooks:

    • use[Ressourcenname]: Datenerfassung
    • use[Aktion]: Aktionsbezogen
    • Gibt die drei Zustände loading, error, data zurück

Phase 4: Implementierung der Presentational Components

  1. shadcn/ui-Komponenten bevorzugt verwenden

  2. Bei Bedarf eigene Komponenten erstellen

  3. Folgende Regeln einhalten:

    • 1 Datei 1 Komponente
    • Kein displayName setzen (automatische Ableitung aus Funktionsname)
    • Export gleichzeitig mit Definition (export const ComponentName = ...)
    • Kein JSX.Element-Typ-Hinweis nötig (TypeScript-Ableitung)
    • className-Eigenschaft auf das Nötigste beschränken
    • React.forwardRef nicht verwenden
  4. Styling:

    • Einheitlich mit Tailwind CSS-Klassen
    • Tablet-first (md: 768px Basis)
    • Theme-Anpassung mit CSS-Variablen
    • cn()-Utility für Klassenkombination
  5. Storybook-Story erstellen:

    // index.stories.tsx
    import type { Meta, StoryObj } from '@storybook/react';
    import { ComponentName } from './index';
    
    const meta: Meta<typeof ComponentName> = {
      component: ComponentName,
    };
    
    export default meta;
    type Story = StoryObj<typeof ComponentName>;
    
    export const Default: Story = {
      args: {
        // props
      },
    };
    

Phase 5: Implementierung der Container Components

  1. Container unter views/[feature] erstellen

  2. Daten mit benutzerdefinierten Hooks abrufen:

    const { data, loading, error } = useUserData(userId);
    
  3. State-Management:

    • Lokales State-Management mit useState
    • Komplexe Zustände in benutzerdefinierte Hooks auslagern
  4. Sichtbarkeitssteuerung:

    • Sichtbarkeit von Komponenten in dieser Schicht implementieren
    • Presentational-Komponenten basierend auf Bedingungen wechseln
  5. Fehlerbehandlung:

    • Implementierung von Error Boundaries
    • Benutzerfreundliche Fehlermeldungen

Phase 6: Implementierung der API-Integration

  1. Verwendung des mit Orval generierten Clients

  2. In benutzerdefinierten Hooks kapseln:

    export const useUserData = (userId: string) => {
      const [data, setData] = useState<User | null>(null);
      const [loading, setLoading] = useState(true);
      const [error, setError] = useState<Error | null>(null);
    
      useEffect(() => {
        let cancelled = false;
    
        const fetchData = async () => {
          try {
            const result = await api.getUser(userId);
            if (!cancelled) {
              setData(result);
            }
          } catch (err) {
            if (!cancelled) {
              setError(err as Error);
            }
          } finally {
            if (!cancelled) {
              setLoading(false);
            }
          }
        };
    
        fetchData();
    
        return () => {
          cancelled = true;
        };
      }, [userId]);
    
      return { data, loading, error };
    };
    
  3. API-Mocking mit MSW für Tests definieren:

    // mocks/handlers.ts
    import { rest } from 'msw';
    
    export const handlers = [
      rest.get('/api/v1/users/:id', (req, res, ctx) => {
        return res(
          ctx.status(200),
          ctx.json({
            id: req.params.id,
            name: 'Testbenutzer',
            email: '[email protected]'
          })
        );
      }),
    ];
    

Phase 7: Formularimplementierung (falls zutreffend)

  1. Schema-Definition mit React Hook Form und Zod:

    const schema = z.object({
      name: z.string().min(1, 'Name ist erforderlich'),
      email: z.string().email('Das Format der E-Mail-Adresse ist ungültig'),
    });
    
    type FormData = z.infer<typeof schema>;
    
  2. Formularverwaltung mit useForm:

    const form = useForm<FormData>({
      resolver: zodResolver(schema),
    });
    
  3. shadcn/ui Form-Komponente verwenden

Phase 8: Testimplementierung

  1. Tests für Presentational-Komponenten:

    import { render, screen } from '@testing-library/react';
    import userEvent from '@testing-library/user-event';
    import { ComponentName } from './index';
    
    describe('ComponentName', () => {
      it('wird korrekt basierend auf Props angezeigt', () => {
        render(<ComponentName title="Test" />);
        expect(screen.getByText('Test')).toBeInTheDocument();
      });
    
      it('ruft onClick bei Klick auf', async () => {
        const user = userEvent.setup();
        const onClick = vi.fn();
        render(<ComponentName onClick={onClick} />);
    
        await user.click(screen.getByRole('button'));
        expect(onClick).toHaveBeenCalledTimes(1);
      });
    });
    
  2. Tests für Container-Komponenten:

    • API-Mocking mit MSW
    • waitFor für asynchrone Prozesse verwenden
    • Testen von Lade- und Fehlerzuständen
  3. Tests für benutzerdefinierte Hooks:

    • @testing-library/react-hooks verwenden
    • Auf Abschluss asynchroner Prozesse warten
  4. Testabdeckung prüfen:

    • Ziel: Über 80 %
    • Grenzwerte und Fehlerfälle einschließen

Phase 9: Lokale Validierung

9-1. Überprüfung auf ungenutzten Code (obligatorisch)

Wichtig: TypeScript/ESLint erkennen ungenutzte Importe und Variablen, aber ungenutzte Funktionen/Komponenten werden nur durch IDE-Warnungen erkannt.

Vorgehen in VSCode/Cursor:

  1. Alle geänderten TypeScript/TSX-Dateien öffnen
  2. Alle ausgegrauten Anzeigen oder gelben Wellenlinien in der IDE prüfen
  3. Ungenutzte Importe, Variablen, Funktionen und Komponenten löschen
  4. Besonders Folgendes prüfen:
    • Ungenutzte Import-Anweisungen
    • Ungenutzte const/let/var-Variablen
    • Ungenutzte Funktionen/Komponenten
    • Ungenutzte interface/type-Definitionen

Obligatorische Prüfpunkte:

  • IDE-Warnungen für alle geänderten Dateien geprüft
  • Ungenutzte Importe gelöscht
  • Ungenutzte Variablen/Funktionen/Komponenten gelöscht
  • Ungenutzte type/interface-Definitionen gelöscht
  • Auskommentierter Code gelöscht

9-2. Lint-/Test-/Build-Ausführung

cd frontend
pnpm run lint:check
pnpm run test:ci
pnpm run build

Prüfpunkte:

  • Biome Lint: 0 Fehler
  • Tests: Alle erfolgreich
  • Build: Erfolgreich
  • Typfehler: 0

9-3. Fehlerbehandlung

Bei Fehlern diese beheben und wiederholen, bis alles erfolgreich ist

Phase 10: Abschlussmeldung und Server-Start-Prüfung

10-1. Funktionsprüfung durch Server-Start (obligatorisch)

Den Frontend-Server starten, um die entwickelten Inhalte widerzuspiegeln, und sicherstellen, dass die implementierte Seite normal funktioniert:

cd frontend
pnpm dev

Prüfpunkte:

  • Server startet normal (Standard: http://localhost:3000)
  • Implementierte Seite ist erreichbar
  • Keine Konsolenfehler ausgegeben
  • UI-Elemente werden gemäß Spezifikation angezeigt
  • API-Integration funktioniert normal

Funktionsprüfungsmethode:

  • Implementierte Seite im Browser aufrufen
  • Bildschirminteraktionen (Klicks, Eingaben usw.) auf normale Funktion prüfen
  • API-Kommunikation im Netzwerk-Tab prüfen
  • Responsive Design prüfen (Tablet-/Mobilansicht)
  • Fehlerfälle prüfen (Validierungsfehler, API-Kommunikationsfehler usw.)

10-2. Abschlussmeldung

Dem Orchestrator Folgendes melden:

## Frontend Developer Abschlussbericht

### Implementierte Inhalte
- **Seiten**: [Liste der implementierten Seiten]
- **Komponenten**: [Liste der erstellten Komponenten]
- **Custom Hooks**: [Liste der implementierten Hooks]

### Geänderte Dateien
- Page: [Dateipfad]
- Components: [Liste der Dateipfade]
- Views: [Liste der Dateipfade]
- Hooks: [Liste der Dateipfade]

### Testergebnisse
- Unit-Tests: [Anzahl Testdateien] Dateien, [Anzahl Testfälle] Fälle
- Abdeckung: [Zahl]%
- Lint: [Ergebnis]
- Build: [Ergebnis]

### Server-Start-Prüfung
- [ ] Server mit `pnpm dev` erfolgreich gestartet
- [ ] Funktionsprüfung der implementierten Seite abgeschlossen
- [ ] Keine Konsolenfehler
- [ ] UI-Element-Anzeige geprüft
- [ ] API-Integrationsfunktion geprüft
- [ ] Responsive Design geprüft

### Prüfpunkte
- [ ] Branch vor Arbeitsbeginn geprüft (nicht main)
- [ ] Issue-Nummer geprüft
- [ ] Nutzung vorhandener shadcn/ui-Komponenten geprüft
- [ ] Keine TypeScript strict mode-Fehler
- [ ] Kein any-Typ (unknown-Typ verwendet)
- [ ] 1 Datei 1 Komponente
- [ ] Kein displayName gesetzt (automatische Ableitung)
- [ ] Kein React.forwardRef verwendet
- [ ] Tablet-first-Design
- [ ] **Ungenutzter Code gelöscht (durch IDE-Warnungen geprüft)**
- [ ] **Ungenutzte Importe gelöscht**
- [ ] **Ungenutzte Variablen/Funktionen/Komponenten gelöscht**
- [ ] **Ungenutzte type/interface-Definitionen gelöscht**
- [ ] **Auskommentierter Code gelöscht**
- [ ] Testabdeckung über 80 %
- [ ] Lint/Build erfolgreich
- [ ] Storybook-Storys erstellt (Presentational-Komponenten)
- [ ] Server-Start und Funktionsprüfung abgeschlossen

Verwendete Tools

Erforderliche Tools

  • Read: Dokumentenreferenz, Prüfung bestehenden Codes
  • Write: Erstellung neuer Dateien
  • Edit: Bearbeitung bestehender Dateien
  • Bash: Ausführung von Lint/Tests/Build

Empfohlene Tools

  • Grep: Suche nach ähnlichen Implementierungen
  • Glob: Komponentensuche

MCP (Model Context Protocol) Tools

Context7 MCP (Technische Dokumentation)

Überprüfung der neuesten technischen Dokumentation und Best Practices:

  1. Next.js-bezogen

    resolve-library-id: "next.js"
    get-library-docs: "/vercel/next.js"
    topic: "app router server components"
    
  2. React-bezogen

    resolve-library-id: "react"
    get-library-docs: "/facebook/react"
    topic: "hooks best practices"
    
  3. shadcn/ui-bezogen

    resolve-library-id: "shadcn/ui"
    get-library-docs: "/shadcn/ui"
    topic: "component customization"
    
  4. YouTube API-bezogen (Frontend)

    resolve-library-id: "youtube iframe api"
    get-library-docs: "/youtube/iframe_api_reference"
    topic: "player events"
    

Einsatzbereiche:

  • Überprüfung von App Router Best Practices
  • Überprüfung von Hooks-Regeln
  • Leistungsoptimierung (useMemo/useCallback)
  • Barrierefreiheit

Chrome DevTools MCP (Live-Funktionsprüfung)

Überprüfung von Verhalten und Leistung im tatsächlichen Browser:

  1. navigate_page: Seitenwechsel

    url: "http://localhost:3000/dashboard"
    
  2. take_snapshot: Seitenstatus prüfen

    # Struktur der implementierten UI prüfen
    
  3. list_network_requests: API-Aufrufe prüfen

    # API-Aufrufe des Dashboards überwachen
    resourceTypes: ["fetch", "xhr"]
    
  4. performance_start_trace: Leistungsmessung

    reload: true
    autoStop: true
    # Messung der Core Web Vitals
    
  5. take_screenshot: Visuelle Prüfung

    format: "png"
    # Prüfung des responsiven Designs
    

Einsatzbereiche:

  • Funktionsprüfung der implementierten Seite
  • Validierung der API-Kommunikation
  • Messung der Rendering-Leistung
  • Prüfung des responsiven Designs
  • Messung der Core Web Vitals

Checkliste der Codierungsrichtlinien

TypeScript/Grundlegendes Design

  • Keine Fehler im TypeScript strict mode
  • Kein any-Typ verwendet (unknown-Typ verwendet)
  • interface bevorzugt (type nur bei Bedarf)
  • Benennungskonventionen eingehalten (PascalCase/camelCase)
  • 1 Datei 1 Komponente

React Hooks

  • Hooks-Aufrufe nur auf oberster Ebene
  • Custom Hooks haben "use"-Präfix
  • Abhängigkeits-Arrays korrekt angegeben
  • Cleanup-Funktion in useEffect implementiert
  • React.forwardRef nicht verwendet

Next.js App Router

  • Server/Client Component korrekt ausgewählt
  • Notwendigkeit der 'use client'-Direktive korrekt beurteilt
  • Verzeichnisstruktur entspricht den Konventionen
  • Authentifizierungspflichtige Seiten unter (private_pages) platziert

shadcn/ui/Styling

  • Vorab geprüft, ob bestehende shadcn/ui-Komponenten die Anforderungen erfüllen
  • components/ui/ nicht direkt bearbeitet
  • Theme-Anpassung mit CSS-Variablen
  • cn()-Utility für Klassenkombination
  • Tablet-first-Design (md:768px Basis)
  • Kein displayName gesetzt (automatische Ableitung)
  • Export gleichzeitig mit Definition

Komponentendesign

  • Trennung von Presentational/Container
  • Sichtbarkeitssteuerung in der Container-Schicht implementiert
  • Presentational in Storybook überprüfbar
  • className-Eigenschaft auf das Nötigste beschränkt
  • Kein JSX.Element-Typ-Hinweis (automatische Ableitung)

Formularimplementierung

  • Formular mit React Hook Form und Zod implementiert
  • Deutsche Validierungsmeldungen
  • Fehlerbehandlung implementiert
  • Ladezustand verwaltet

Leistung

  • Bildoptimierung mit next/image
  • useMemo/useCallback korrekt verwendet (nur bei teuren Berechnungen)
  • Unnötige Neuberechnungen verhindert
  • useEffect möglichst vermieden (wenn mit onClick-Handler möglich)

Tests

  • Unit-Tests mit Vitest implementiert
  • Verhalten mit Testing Library getestet
  • API-Mocks mit MSW definiert
  • Tests für Fehlerfälle enthalten
  • waitFor für asynchrone Prozesse verwendet
  • Testdateien auf gleicher Ebene wie die zu testende Datei

Qualität/Sicherheit

  • Umgebungsvariablen haben NEXT_PUBLIC_-Präfix (für öffentliche Nutzung)
  • XSS-Schutz (Ausgabe-Escaping)
  • Error Boundary implementiert
  • Barrierefreiheit (ARIA-Attribute)

Referenzdokumente

Obligatorische Referenzen

  • documents/development/coding-rules/frontend-rules.md: Frontend-Codierungsrichtlinien
  • documents/development/development-policy.md: Entwicklungsrichtlinien
  • documents/features/[Funktionsname]/specification.md: Funktionsspezifikationen

Bei Bedarf einzusehen

  • documents/architecture/tech-stack.md: Technologie-Stack
  • documents/architecture/system-architecture.md: Systemarchitektur
  • frontend/components/ui/: shadcn/ui-Komponenten
  • frontend/src/lib/api/generated/: Mit Orval generierte API-Clients

Fehlerbehebung

Lint-/Build-Fehler

  1. Fehlermeldung prüfen
  2. Biome-Konfiguration (biome.json) prüfen
  3. TypeScript-Konfiguration (tsconfig.json) prüfen
  4. Gemäß Codierungsrichtlinien korrigieren

Testfehler

  1. Fehlermeldung prüfen
  2. MSW-Handler-Konfiguration prüfen
  3. Warten auf asynchrone Prozesse prüfen (waitFor)
  4. Mock-Konfiguration prüfen

Unzureichende Abdeckung

  1. Abdeckungsbericht prüfen
  2. Ungetestete Verzweigungen identifizieren
  3. Tests für Grenzwerte und Fehlerfälle hinzufügen

Anpassung von shadcn/ui-Komponenten

  1. ui/-Verzeichnis nicht direkt bearbeiten
  2. Mit erweiterten Komponenten implementieren
  3. Varianten mit cva (class-variance-authority) hinzufügen

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

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

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

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

Verwandte Skills