frontend-patterns

Provide reusable component, hook, and state management patterns for React and Next.js projects.

Updated Jan 24, 2026
One-click install
npx skills add https://github.com/feldboy/parlament-app --skill frontend-patterns-feldboy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: frontend-patterns
Source: https://github.com/feldboy/parlament-app/tree/main/.claude/skills/frontend-patterns
Command: npx skills add https://github.com/feldboy/parlament-app --skill frontend-patterns-feldboy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Frontend Pattern guide helps teams apply proven frontend design patterns to build scalable, maintainable UIs across React and Next.js projects.

Core Features & Use Cases

  • Component patterns: composition, compound components, render props for flexible UI composition.
  • Hooks and state management: custom hooks, context + reducer patterns to manage complex state.
  • Performance and accessibility: memoization, code-splitting, virtualization, keyboard navigation.
  • Use case: design systems, shared component libraries, and performance-tuned dashboards.

Quick Start

Apply a composition-first pattern to a sample component and extend it with small, focused subcomponents.

Frequently Asked Questions about frontend-patterns

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

FAQPage Schema
What are the best frontend patterns for building scalable React and Next.js UIs?

Best frontend patterns for scalable React and Next.js UIs include composition, compound components, and custom hooks. These patterns enable flexible UI composition and complex state management, ensuring your design system or component library remains maintainable as it grows.

How do I manage complex state in a React component library without prop drilling?

Manage complex state in a React component library using custom hooks and context combined with reducer patterns. This approach encapsulates state logic, prevents prop drilling, and maintains predictable state transitions across your shared UI components.

How do I optimize React performance for large lists and data-heavy dashboards?

Optimize React performance for data-heavy dashboards using memoization, code-splitting, and virtualization techniques. These frontend patterns reduce unnecessary re-renders and limit the DOM nodes rendered, keeping complex UIs fast and responsive.

Does this frontend pattern guide cover accessibility and keyboard navigation?

Yes, this frontend pattern guide covers accessibility and keyboard navigation. It provides techniques to implement accessible interactions within your React components, ensuring design systems meet accessibility standards alongside performance optimizations.

When should I use compound components over render props in React?

Use compound components for implicit state sharing and tighter UI coupling, and render props for flexible composition logic. Both frontend patterns solve UI composition problems, but compound components suit design systems while render props offer explicit rendering control.

Can I apply these frontend patterns to existing shared component libraries?

Yes, you can apply these frontend patterns to existing shared component libraries. The composition-first approach allows you to refactor monolithic components into small, focused subcomponents and extend them incrementally without breaking current implementations.