New to Claude Skills? Learn how to install them →

cosscom on GitHub

COSS UI

Free

Streamline your UI development with COSS components.

Get this skill

Free · Opens the source repo

What COSS UI does

COSS UI is a comprehensive component library designed to facilitate the development of user interfaces using COSS primitives. It offers a developer experience similar to shadcn, making it easier to implement UI components like buttons, dialogs, and forms. This skill is particularly useful for developers transitioning from shadcn/Radix to COSS/Base UI, as it helps avoid common pitfalls and ensures correct usage of components. By leveraging this skill, you can efficiently create production-ready patterns with the provided examples and documentation.

The skill guides users through selecting the appropriate COSS primitives for their specific UI tasks, ensuring that code is written correctly with the right imports and props. It emphasizes the importance of accessibility and proper composition, which are crucial for creating user-friendly interfaces. Additionally, the skill provides a wealth of resources, including a catalog of particle examples and a detailed mapping of COSS components, which can significantly speed up the development process.

This skill is ideal for frontend developers and designers who are looking to enhance their UI projects with COSS components. Whether you're building a new application or migrating an existing one, this skill offers the necessary tools and guidance to implement COSS UI components effectively. By following the outlined principles and rules, users can ensure that their implementations are not only functional but also maintain high standards of accessibility and usability.

In summary, COSS UI is a valuable resource for anyone involved in UI development with COSS components. It provides the necessary guidance and examples to streamline the process, making it easier to create visually appealing and functional user interfaces.

When to use it

Use this skill when developing UIs with COSS primitives or migrating from shadcn/Radix to COSS/Base UI.

When not to use it

This skill may not be suitable for projects that do not utilize COSS components or require custom markup outside the provided primitives.

What you can build with it

Building a New Application

Utilize the COSS UI skill to efficiently implement UI components for a new project, ensuring best practices are followed.

Migrating an Existing Project

Leverage the skill to transition from shadcn/Radix to COSS, avoiding common pitfalls during the migration process.

Creating Accessible Interfaces

Use the skill to ensure that all COSS components are implemented with accessibility in mind, improving user experience.

How to install COSS UI

View source

1. Install with the skills CLI

npx skills add cosscom/coss/coss --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by cosscom

coss ui

coss ui is a component library built on Base UI with a shadcn-like developer experience plus a large particle catalog.

What this skill is for

Use this skill to:

  • pick the right coss primitive(s) for a UI task
  • write correct coss usage code (imports, composition, props)
  • avoid common migration mistakes from shadcn/Radix assumptions
  • reference particle examples to produce practical, production-like patterns

Source of truth

  • coss components docs: apps/ui/content/docs/components/*.mdx
    • https://github.com/cosscom/coss/tree/main/apps/ui/content/docs/components
  • coss particle examples: apps/ui/registry/default/particles/p-*.tsx
    • https://github.com/cosscom/coss/tree/main/apps/ui/registry/default/particles
  • coss particles catalog: https://coss.com/ui/particles
  • docs map for agents: https://coss.com/ui/llms.txt

Out of scope

  • Maintaining coss monorepo internals/build pipelines.
  • Editing registry internals unless explicitly requested.

Principles for agent output

  1. Use existing primitives and particles first before inventing custom markup.
  2. Prefer composition over custom behavior reimplementation.
  3. Follow coss naming and APIs from docs exactly.
  4. Keep examples accessible and production-realistic.
  5. Prefer concise code that mirrors coss docs/particles conventions.
  6. Assume Tailwind CSS v4 conventions in coss examples and setup guidance.

Critical usage rules

Always apply before returning coss code:

  • Do not invent coss APIs. Verify against component docs first.
  • For trigger-based primitives (Dialog, Menu, Select, Popover, Tooltip), follow each primitive's documented trigger/content hierarchy and composition API; do not mix patterns across components.
  • Preserve accessibility labels and error semantics.
  • Consult primitive-specific guides for component invariants and edge cases.
  • For manual install guidance, include all required dependencies and local component files referenced by imports.
  • Prefer styled coss exports first; use *Primitive exports only when custom composition/styling requires it.

Rule references (read on demand when the task touches these areas):

  • ./references/rules/styling.md — Tailwind tokens, icon conventions, data-slot selectors
  • ./references/rules/forms.md — Field composition, validation, input patterns
  • ./references/rules/composition.md — Trigger/popup hierarchies, grouped controls
  • ./references/rules/migration.md — shadcn/Radix to coss/Base UI migration patterns
  • ./references/portal-props.md — optional portalProps on composed popups and toast providers (keepMounted, container, which surfaces support it)

Component discovery

All 54 primitives have dedicated reference guides at ./references/primitives/<name>.md. To find the right one for a task, consult the component registry index:

  • ./references/component-registry.md

Usage workflow

  1. Identify user intent (single primitive, composed flow, form flow, overlay flow, feedback flow).
  2. Consult references/component-registry.md to identify candidate primitives.
  3. Select primitives from coss docs first; avoid custom fallback unless needed.
  4. Check at least one particle example for practical composition patterns. Particle files live at apps/ui/registry/default/particles/p-<name>-<N>.tsx (e.g. p-dialog-1.tsx).
  5. Write minimal code using documented imports/props.
  6. Self-check accessibility and composition invariants.

Installation reference

See ./references/cli.md for full install/discovery workflow.

Quick CLI pattern:

npx shadcn@latest add @coss/<component>

Quick manual pattern:

  • install dependencies listed in the component docs page
  • copy required component file(s)
  • update imports to match the target app alias setup

Primitive Guidance

Every primitive has a reference guide at ./references/primitives/<name>.md with imports, minimal patterns, inline code examples, pitfalls, and particle references. Use the component registry to find the right file.

High-risk primitives (read these guides first -- they have the most composition gotchas):

  • ./references/primitives/dialog.md — modal overlays, form-in-dialog, responsive dialog/drawer
  • ./references/primitives/menu.md — dropdown actions, checkbox/radio items, submenus
  • ./references/primitives/context-menu.md — right-click/long-press menus at the pointer
  • ./references/primitives/select.md — items-first pattern, multiple, object values, groups
  • ./references/primitives/form.md — Field composition, validation, submission
  • ./references/primitives/input-group.md — addons, DOM order invariant, textarea layouts
  • ./references/primitives/toast.md — toastManager (not Sonner), anchored toasts, providers

Output Checklist

Before returning code:

  • imports and props match coss docs
  • composition structure is valid for selected primitive(s)
  • accessibility and explicit control types (button, input, etc.) are present
  • migration-sensitive flows are verified (type/lint, keyboard/a11y behavior, and SSR-sensitive primitives like Select/Command)

Frequently asked questions about COSS UI

Similar skills