
Core Components
- 558 installs
- 44.4k repo stars
- Updated August 4, 2026
- sickn33/antigravity-awesome-skills
core-components is a frontend design-system skill that helps developers build consistent UIs by using shared components and design tokens instead of hard-coded spacing and style values.
About
Core Components is a community design-system skill that tells coding agents how your product UI should be assembled: reach for the shared library, never inline arbitrary pixels or hex colors, and use documented spacing, color, and typography tokens. developers shipping SaaS or mobile clients can attach it whenever the agent is generating screens, forms, or layouts so output matches an existing Tamagui-style or similar token layer. The readme is prescriptive tables and CORRECT versus WRONG examples rather than a multi-step ritual, so it behaves as phase-specific frontend guidance. It does not install components or run Storybook; it shapes agent behavior to align with your system. Use alongside your actual component package names in the repo so the agent imports the right primitives.
- Enforces use of design tokens for spacing, color, and typography
- Prevents hard-coded pixel values and inline styles
- Provides semantic color tokens for text, brand, status, and backgrounds
- Includes ready-to-use spacing scale from $1 (4px) to $8 (32px)
- Guarantees consistent styling and behavior across your product
Core Components by the numbers
- 558 all-time installs (skills.sh)
- +25 installs in the week ending Jun 23, 2026 (Skillselion tracking)
- Ranked #548 of 1,880 Design & UI/UX skills by installs in the Skillselion catalog
- Security screen: LOW risk (skills.sh audit)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill core-componentsAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 558 |
|---|---|
| repo stars | ★ 44.4k |
| Security audit | 3 / 3 scanners passed |
| Last updated | August 4, 2026 |
| Repository | sickn33/antigravity-awesome-skills ↗ |
How do you enforce design tokens in AI-generated UI?
Enforce consistent UI patterns and design tokens instead of hard-coding values when creating interfaces with AI coding agents.
Who is it for?
Frontend developers with an existing component library who want AI agents to respect design tokens and shared primitives.
Skip if: Greenfield projects without a component library or teams that intentionally use inline styles without a token system.
When should I use this skill?
An agent is building UI, adding layouts, or hard-coding spacing, colors, or raw platform components.
What you get
Token-based TSX components, consistent spacing scale usage, and no hard-coded pixel values in new UI.
- Token-compliant TSX components
- Consistent spacing and layout usage
By the numbers
- Documents spacing token `$1` as 4px and `$2` as 8px
Files
Core Components
Design System Overview
Use components from your core library instead of raw platform components. This ensures consistent styling and behavior.
Design Tokens
NEVER hard-code values. Always use design tokens.
Spacing Tokens
// CORRECT - Use tokens
<Box padding="$4" marginBottom="$2" />
// WRONG - Hard-coded values
<Box padding={16} marginBottom={8} />| Token | Value |
|---|---|
$1 | 4px |
$2 | 8px |
$3 | 12px |
$4 | 16px |
$6 | 24px |
$8 | 32px |
Color Tokens
// CORRECT - Semantic tokens
<Text color="$textPrimary" />
<Box backgroundColor="$backgroundSecondary" />
// WRONG - Hard-coded colors
<Text color="#333333" />
<Box backgroundColor="rgb(245, 245, 245)" />| Semantic Token | Use For |
|---|---|
$textPrimary | Main text |
$textSecondary | Supporting text |
$textTertiary | Disabled/hint text |
$primary500 | Brand/accent color |
$statusError | Error states |
$statusSuccess | Success states |
Typography Tokens
<Text fontSize="$lg" fontWeight="$semibold" />| Token | Size |
|---|---|
$xs | 12px |
$sm | 14px |
$md | 16px |
$lg | 18px |
$xl | 20px |
$2xl | 24px |
Core Components
Box
Base layout component with token support:
<Box
padding="$4"
backgroundColor="$backgroundPrimary"
borderRadius="$lg"
>
{children}
</Box>HStack / VStack
Horizontal and vertical flex layouts:
<HStack gap="$3" alignItems="center">
<Icon name="user" />
<Text>Username</Text>
</HStack>
<VStack gap="$4" padding="$4">
<Heading>Title</Heading>
<Text>Content</Text>
</VStack>Text
Typography with token support:
<Text
fontSize="$lg"
fontWeight="$semibold"
color="$textPrimary"
>
Hello World
</Text>Button
Interactive button with variants:
<Button
onPress={handlePress}
variant="solid"
size="md"
isLoading={loading}
isDisabled={disabled}
>
Click Me
</Button>| Variant | Use For |
|---|---|
solid | Primary actions |
outline | Secondary actions |
ghost | Tertiary/subtle actions |
link | Inline actions |
Input
Form input with validation:
<Input
value={value}
onChangeText={setValue}
placeholder="Enter text"
error={touched ? errors.field : undefined}
label="Field Name"
/>Card
Content container:
<Card padding="$4" gap="$3">
<CardHeader>
<Heading size="sm">Card Title</Heading>
</CardHeader>
<CardBody>
<Text>Card content</Text>
</CardBody>
</Card>Layout Patterns
Screen Layout
const MyScreen = () => (
<Screen>
<ScreenHeader title="Page Title" />
<ScreenContent padding="$4">
{/* Content */}
</ScreenContent>
</Screen>
);Form Layout
<VStack gap="$4" padding="$4">
<Input label="Name" {...nameProps} />
<Input label="Email" {...emailProps} />
<Button isLoading={loading}>Submit</Button>
</VStack>List Item Layout
<HStack
padding="$4"
gap="$3"
alignItems="center"
borderBottomWidth={1}
borderColor="$borderLight"
>
<Avatar source={{ uri: imageUrl }} size="md" />
<VStack flex={1}>
<Text fontWeight="$semibold">{title}</Text>
<Text color="$textSecondary" fontSize="$sm">{subtitle}</Text>
</VStack>
<Icon name="chevron-right" color="$textTertiary" />
</HStack>Anti-Patterns
// WRONG - Hard-coded values
<View style={{ padding: 16, backgroundColor: '#fff' }}>
// CORRECT - Design tokens
<Box padding="$4" backgroundColor="$backgroundPrimary">
// WRONG - Raw platform components
import { View, Text } from 'react-native';
// CORRECT - Core components
import { Box, Text } from 'components/core';
// WRONG - Inline styles
<Text style={{ fontSize: 18, fontWeight: '600' }}>
// CORRECT - Token props
<Text fontSize="$lg" fontWeight="$semibold">Component Props Pattern
When creating components, use token-based props:
interface CardProps {
padding?: '$2' | '$4' | '$6';
variant?: 'elevated' | 'outlined' | 'filled';
children: React.ReactNode;
}
const Card = ({ padding = '$4', variant = 'elevated', children }: CardProps) => (
<Box
padding={padding}
backgroundColor="$backgroundPrimary"
borderRadius="$lg"
{...variantStyles[variant]}
>
{children}
</Box>
);Integration with Other Skills
- react-ui-patterns: Use core components for UI states
- testing-patterns: Mock core components in tests
- storybook: Document component variants
When to Use
This skill is applicable to execute the workflow or actions described in the overview.
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
Related skills
How it compares
Use core-components when a shared library and token scale already exist; use a generator skill when you still need to create the design system from scratch.
FAQ
Should core-components allow hard-coded pixel values?
core-components forbids hard-coded values. Agents must use design tokens such as `<Box padding="$4" marginBottom="$2" />` instead of numeric literals like `padding={16}`.
When should you invoke core-components?
core-components applies while building UI, working with design tokens, or touching the shared component library. Use it whenever agents might import raw platform components or invent ad hoc spacing.
Is Core Components safe to install?
skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.