ck:frontend-development

Provide React/TypeScript frontend guidelines using Suspense, lazy loading, MUI v7, TanStack Query, and TanStack Router.

1|Updated May 4, 2026
One-click install
npx skills add https://github.com/auxi-wardrobe/auxi-all-in --skill ck-frontend-development-auxi-wardrobe
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ck:frontend-development
Source: https://github.com/auxi-wardrobe/auxi-all-in/tree/main/.agents/skills/frontend-development
Command: npx skills add https://github.com/auxi-wardrobe/auxi-all-in --skill ck-frontend-development-auxi-wardrobe

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires react, react-query, mui, typescript, tanstack-query, tanstack-router, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill streamlines the process of building modern React/TypeScript frontends, reducing development time and improving code quality.

Core Features & Use Cases

  • Modern Patterns: Follows best practices for React development with Suspense, lazy loading, and TypeScript.
  • Component Creation: Offers guidelines for creating efficient and maintainable React components.
  • Data Fetching: Implements efficient data fetching using TanStack Query with cache-first strategies.
  • Routing: Provides instructions for setting up and managing routes with TanStack Router.
  • Styling: Offers guidance on using MUI v7 for styling and component theming.
  • Performance Optimization: Shares best practices for optimizing performance in modern web applications.
  • Use Case: When building a new feature or component, use this Skill to ensure it follows best practices and integrates seamlessly with the rest of the application.

Quick Start

Create a new React component using the following steps:

  1. Use the React.FC<Props> pattern with TypeScript for type safety.
  2. Lazy load the component if it is heavy.
  3. Wrap the lazy component in <SuspenseLoader> for smooth loading.
  4. Use useSuspenseQuery for data fetching.
  5. Import necessary aliases for easier navigation.
  6. Style the component using MUI v7 or inline styles.
  7. Use useCallback for event handlers passed to children.

Frequently Asked Questions about ck:frontend-development

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

FAQPage Schema
How do I fetch data in React using TanStack Query and Suspense?

Implement cache-first data fetching in React by combining the `useSuspenseQuery` hook from TanStack Query with React's `<SuspenseLoader>` component. This pattern ensures efficient data retrieval while providing smooth loading states for lazy-loaded components.

What is the best way to structure TypeScript types for React components?

Structure TypeScript types for React components using the `React.FC<Props>` pattern. This ensures strict type safety for your component inputs, which is essential for building maintainable and efficient UI components in modern React development.

How do I set up routing in a React application with TanStack Router?

Set up routing in a React application with TanStack Router by following its specific guidelines for route management. This integrates seamlessly with modern patterns like lazy loading and Suspense, ensuring efficient navigation and data fetching within your TypeScript frontend.

Does MUI v7 work well with React lazy loading and Suspense?

MUI v7 works seamlessly with React lazy loading and Suspense. You can style components using MUI v7 or inline styles while wrapping heavy, lazy-loaded components in a Suspense boundary, ensuring smooth loading states and optimized frontend performance.

How do I optimize React performance when passing event handlers to child components?

Optimize React performance when passing event handlers to child components by wrapping them in the `useCallback` hook. This prevents unnecessary re-renders in modern web applications, maintaining high performance and code quality while building efficient React components.

Why should I use lazy loading for heavy React components?

Use lazy loading for heavy React components to optimize web application performance. By deferring the loading of heavy components until they are needed and wrapping them in `<SuspenseLoader>`, you reduce the initial bundle size and ensure smooth loading states.