component-architecture

Standardize React component design through composition patterns and responsibility boundaries.

1|Updated Jul 15, 2026
One-click install
npx skills add https://github.com/Dzakiamriz22/frontend-pack --skill component-architecture-dzakiamriz22
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: component-architecture
Source: https://github.com/Dzakiamriz22/frontend-pack/tree/main/skills/component-architecture
Command: npx skills add https://github.com/Dzakiamriz22/frontend-pack --skill component-architecture-dzakiamriz22

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the common challenges of bloated components, inconsistent file organization, and unclear responsibility boundaries in React applications.

Core Features & Use Cases

  • Component Decomposition: Provides patterns for splitting large components into manageable, reusable pieces using smart vs. presentational logic.
  • Composition Patterns: Implements advanced techniques like the Slot pattern and Compound Components to create flexible, decoupled UI elements.
  • Architecture Standards: Enforces a consistent file structure and naming convention to ensure long-term maintainability and easier testing.

Quick Start

Use the component-architecture skill to refactor the current large dashboard component into smaller, feature-based sub-components.

Frequently Asked Questions about component-architecture

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

FAQPage Schema
How do I refactor a large React component into smaller reusable pieces?

Refactoring a large React component involves breaking it down using smart and presentational logic patterns to separate concerns. This skill standardizes component decomposition to enforce clear responsibility boundaries, making UI elements manageable and highly reusable.

What is the best way to structure a React project for long-term maintainability?

The best way to structure a React project for maintainability is enforcing a consistent file organization and naming convention. This architecture standard establishes clear boundaries, ensuring easier testing and adherence to modern best practices over time.

How do compound components and the slot pattern work in React UI design?

Compound components and the slot pattern are advanced composition techniques that create flexible, decoupled UI elements. They allow you to build scalable React component systems where parent components manage state without tightly coupling child component logic.

When should I use smart versus presentational components in React?

You should use smart versus presentational components when decomposing large UI features to ensure modularity. Smart components handle logic and state, while presentational components focus purely on rendering, resulting in highly testable and maintainable React codebases.

Can this component architecture approach handle complex frontend refactoring?

Yes, this component architecture approach handles complex frontend refactoring by applying composition patterns and strict responsibility boundaries. It specifically targets bloated components and inconsistent file organization, optimizing project structure for scalable applications.