vercel-composition

Guide React component architecture with compound patterns and explicit variants.

7|2|Updated Jan 28, 2026
One-click install
npx skills add https://github.com/LuisSambrano/antigravity-config --skill vercel-composition
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: vercel-composition
Source: https://github.com/LuisSambrano/antigravity-config/tree/main/skills/3-web/vercel-composition
Command: npx skills add https://github.com/LuisSambrano/antigravity-config --skill vercel-composition

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides a structured approach to building scalable and maintainable React components, preventing common pitfalls like boolean prop proliferation and enabling flexible, reusable code.

Core Features & Use Cases

  • Component Architecture: Learn to avoid excessive boolean props and structure components using compound patterns.
  • State Management: Implement effective state lifting and context-based dependency injection.
  • Implementation Patterns: Prefer children over render props and create explicit component variants for clarity.
  • Use Case: Refactor a complex UserProfile component that currently uses many boolean flags into a set of well-defined, composable sub-components that are easier to manage and extend.

Quick Start

Apply the vercel composition skill to refactor the Composer component to use compound components and explicit variants.

Frequently Asked Questions about vercel-composition

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

FAQPage Schema
How do I refactor React components to avoid boolean prop proliferation?

You can manage state in React composition patterns by implementing state lifting and context-based dependency injection. This Skill provides structured guidance on using context providers to handle state efficiently within scalable component architectures.

What is the best way to structure scalable React component architecture?

The best way to structure scalable React component architecture is using composition patterns like compound components and explicit variants. This approach prevents boolean prop proliferation and enables flexible, reusable code without relying heavily on render props.

Does this React composition approach work with React 19 API changes?

Yes, this React composition approach works with React 19 API changes. The Skill enforces best practices for component architecture, state management via context providers, and implementation strategies with specific considerations for the React 19 API.

When should I use compound components instead of render props in React?

To refactor React components and avoid boolean prop proliferation, implement compound component patterns and explicit variants. This Skill guides you in restructuring complex components like UserProfile into composable sub-components for better maintainability.