frontend-design-patterns

Structure React applications with DDD and FSD layers and TypeScript conventions.

13|3|Updated Jan 10, 2026
One-click install
npx skills add https://github.com/Mineru98/skills-store --skill frontend-design-patterns-mineru98
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: frontend-design-patterns
Source: https://github.com/Mineru98/skills-store/tree/main/.claude/skills/frontend-design-patterns
Command: npx skills add https://github.com/Mineru98/skills-store --skill frontend-design-patterns-mineru98

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Enterprise frontend codebases often become brittle as they grow, making coordination across teams difficult. This Skill demonstrates how to apply Domain-Driven Design (DDD) and Feature-Sliced Design (FSD) to create scalable, modular React architectures with clear layers, slices, and segments.

Core Features & Use Cases

  • Guidance on structuring apps with App, Pages, Widgets, Features, Entities, and Shared layers.
  • Patterns for Index/Types/Styles components and one-to-one Service/Hook mappings with React Query and Axios.
  • TypeScript conventions, Zustand state management, and robust public API exports.
  • Practical references and example structures to bootstrap projects quickly.

Quick Start

Create a new feature with a full FSD structure and generate the corresponding api, model, and ui layers.

Frequently Asked Questions about frontend-design-patterns

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

FAQPage Schema
How do I structure a large React application using Feature-Sliced Design?

Structure large React applications using Feature-Sliced Design by organizing code into App, Pages, Widgets, Features, Entities, and Shared layers. This architecture enforces unidirectional dependency rules across layers, ensuring your frontend codebase remains modular and scalable as teams grow.

What is the best way to manage state and data fetching in a FSD React architecture?

Manage state and data fetching in a FSD React architecture by establishing a one-to-one mapping between service functions and hooks. Use React Query for data fetching, Zustand for state management, and Axios for requests, exposing them through explicit public APIs via index.ts files.

How do I apply Domain-Driven Design principles to a React frontend?

Apply Domain-Driven Design to a React frontend by mapping domain logic to specific FSD layers like Entities and Features. This approach isolates business logic into independent slices with strict TypeScript conventions, preventing domain boundaries from bleeding into UI components.

Does this React FSD architecture work with strict TypeScript conventions?

Yes, this React FSD architecture works with strict TypeScript conventions. It enforces robust type safety across all layers, slices, and segments, ensuring that explicit public API exports and one-to-one service/hook mappings are fully type-checked during development.

Why does my React enterprise codebase become brittle as it scales across teams?

React enterprise codebases become brittle as they scale because of unclear module boundaries and tangled dependencies. Applying DDD and FSD patterns solves this by enforcing unidirectional dependency rules and explicit public API exposure, making coordination across teams manageable.

How do I generate a new feature with full FSD layers in a React project?

Generate a new feature with full FSD layers by creating corresponding api, model, and ui segments within the feature slice. This quick start approach bootstraps the project structure quickly, providing practical references and example structures for immediate implementation.