frontend-dev-guidelines

Provide React/TypeScript frontend guidelines covering Suspense data fetching, lazy loading, MUI v7, and TanStack Router.

111|21|Updated Sep 17, 2025
One-click install
npx skills add https://github.com/Dimon94/cc-devflow --skill frontend-dev-guidelines-dimon94
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: frontend-dev-guidelines
Source: https://github.com/Dimon94/cc-devflow/tree/main/.claude/skills/_reference-implementations/frontend-react-mui
Command: npx skills add https://github.com/Dimon94/cc-devflow --skill frontend-dev-guidelines-dimon94

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides comprehensive guidelines for building high-performance, maintainable React/TypeScript frontend applications using modern patterns. It ensures consistency, optimizes for user experience, and simplifies complex tasks like data fetching, styling, and routing.

Core Features & Use Cases

  • Suspense-Based Data Fetching: Guides on useSuspenseQuery and SuspenseLoader for efficient loading states without layout shifts.
  • Modular File Organization: Prescribes features/ vs. components/ structure, import aliases, and naming conventions for a clean codebase.
  • MUI v7 Styling & TanStack Router: Provides best practices for responsive UI design and folder-based routing, ensuring a consistent look and feel.
  • Use Case: A developer needs to create a new user profile page. This skill provides a checklist for new components, guides on data fetching with useSuspenseQuery, and explains how to organize the feature's files and styles.

Quick Start

To create a new React component, use the React.FC<Props> pattern, lazy load if heavy, and wrap it in <SuspenseLoader>.

Frequently Asked Questions about frontend-dev-guidelines

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

FAQPage Schema
How do I structure a React/TypeScript project with modern file organization?

Organize your React/TypeScript project using a features-based folder structure that separates feature directories from shared components, apply import aliases for cleaner paths, and follow naming conventions for consistency. This approach reduces import depth, improves maintainability, and scales as your codebase grows.

What's the best way to handle data fetching in React with Suspense?

Use useSuspenseQuery with SuspenseLoader boundaries to fetch data efficiently without layout shifts. This pattern combines TanStack Query's data management with React Suspense, enabling declarative loading states and cleaner component code compared to traditional useEffect patterns.

How do I style components with MUI v7 in a TypeScript React app?

Use the MUI sx styling prop for inline responsive styles in your React.FC components, combining sx with TypeScript's strict typing for type-safe, maintainable styling. This approach keeps styles colocated with components while supporting theme tokens and media queries.

Can I optimize performance in React apps with code-splitting and lazy loading?

Yes. Use React.lazy for code-splitting heavy components and wrap them in SuspenseLoader boundaries to defer loading until needed. Combined with TanStack Router's folder-based routing, this reduces initial bundle size and improves time-to-interactive for users.

What routing pattern works best for large React applications?

TanStack Router with folder-based file organization provides type-safe, scalable routing for React/TypeScript apps. This pattern integrates with feature-based project structure, supports nested routes, and works seamlessly with Suspense-based data fetching and lazy-loaded components.

Do I need strict TypeScript typings for functional React components?

Yes. Enforce strict TypeScript typings with React.FC<Props> pattern to catch type errors at development time, improve IDE autocomplete, and ensure maintainability. Combined with useSuspenseQuery's typed queries, this prevents runtime errors in data fetching and component props.