frontend-patterns

Generate React and Next.js patterns for state, data fetching, and accessibility.

Updated Mar 26, 2026
One-click install
npx skills add https://github.com/luongldptit/move-ticket --skill frontend-patterns-luongldptit
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: frontend-patterns
Source: https://github.com/luongldptit/move-ticket/tree/main/.agent/.agents/skills/frontend-patterns
Command: npx skills add https://github.com/luongldptit/move-ticket --skill frontend-patterns-luongldptit

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the common pain point of inconsistent, unoptimized React and Next.js code that leads to poor application performance, hard-to-maintain codebases, and accessibility non-compliance for end users.

Core Features & Use Cases

  • Reusable Component Patterns: Pre-vetted patterns for component composition, compound components, render props, and error boundaries to build scalable, reusable UI.
  • State & Data Management: Best practices for React state hooks, custom hooks, Context + Reducer, and data fetching with SWR or React Query.
  • Performance & Accessibility: Optimized implementations for memoization, code splitting, list virtualization, keyboard navigation, and focus management to deliver fast, inclusive user experiences.
  • Use Case Example: If you are building a market dashboard with a large list of tradable assets, use this skill to implement virtualized rendering and memoized card components to eliminate scroll lag and reduce unnecessary re-renders.

Quick Start

Use the frontend-patterns skill to implement a virtualized, memoized list of market cards for your Next.js dashboard to handle large datasets without performance degradation.

Frequently Asked Questions about frontend-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What's the best way to optimize React component performance for large lists?▼

To optimize React component performance for large lists, implement list virtualization alongside memoized card components. This approach eliminates scroll lag and prevents unnecessary re-renders when rendering large datasets in your Next.js dashboard.

How do I manage state in React without causing maintainability issues?▼

Manage React state maintainability by applying pre-vetted patterns including custom hooks, Context combined with Reducers, and data fetching libraries like SWR or React Query to ensure consistent state architecture across your application.

How do I make my Next.js frontend WCAG compliant for accessibility?▼

Make your Next.js frontend WCAG compliant by implementing keyboard navigation and focus management patterns. These accessibility features deliver inclusive user experiences and close accessibility gaps in unoptimized React codebases.

When do I need compound components in React architecture?▼

You need compound components in React architecture when building scalable and reusable UI structures. This component pattern allows for flexible composition and shared implicit state without prop drilling across deeply nested elements.

Does this approach work with both React and Next.js codebases?▼

Yes, these frontend patterns work with both React and Next.js codebases. The production-ready implementations apply to component architecture design, form handling, and performance optimization across both frameworks interchangeably.

Why does my React application suffer from poor performance and scroll lag?▼

Your React application suffers from poor performance and scroll lag due to unoptimized code lacking memoization and code splitting. Implementing list virtualization and optimized rendering patterns resolves these performance bottlenecks.