Skip to main content
Unlisted page
This page is unlisted. Search engines will not index it, and only users having a direct link can access it.

Evaluation criteria for design systems / UI kits / CSS frameworks

This is a generic, standalone reference of 39 industry-standard evaluation criteria used to compare products in the CSS / UI / design-system landscape. The criteria are chosen to reflect how engineering teams, design-system architects, and AI tools actually evaluate options when picking a foundation.

Each criterion is defined with: what it measures, the scale (categorical / count / YES-PARTIAL-NO), why it matters from a consumer perspective, and a reference value for Semetrika with implementation evidence (file paths and rule numbers from the Semetrika source).

Vocabulary: the criteria below use terms from the glossary - value, capability, token, primitive token, semantic token, theme, scheme, colour scheme, classless, mirror class, progressive enhancement, visual regression, llms.txt, MCP server, markup portability, customisation locality, etc. Where a term has a contested or surprising meaning across frameworks (notably variant), the glossary disambiguates with a what it is NOT column. Refer to it if any term used here is unfamiliar or seems to mean something different than expected.


Quick-scan summary​

#GroupCriterionWhat it measuresScale
A1DeliveryDrop-in distributionSingle CDN link / script tag, no build pipeline at consumer sideYES / PARTIAL / NO
A2DeliveryCSS source formatWhat the consumer's CSS pipeline must understandVanilla / Sass / PostCSS / CSS-in-JS / Tailwind
A3DeliveryJS framework requirementWhat JS framework (if any) must be presentNone / React / Vue / Svelte / Web components / Multiple
A4DeliveryRuntime dependency countNumber of runtime npm dependenciesCount (0 / 1-3 / 4-9 / 10+)
A5DeliveryLicenseOpen-source license termsPermissive / Copyleft / Proprietary
B1CompletenessComponent scopeTotal count of named components / utilities / patterns / pagesBreakdown numbers
B2CompletenessIconographyBuilt-in icon system or packBuilt-in (system + pack) / Built-in (component only) / Integrated 3rd-party / NO
B3CompletenessServer-side template parityComponents ship in SSR template language (Twig / Liquid / Nunjucks / etc.)YES (language) / PARTIAL / NO
B4CompletenessReference page templatesFull-page reference implementations beyond componentsCount or YES / NO
C1CustomizationCustomization surfacesWhat can be customized: variables / tokens / components / patterns / plugins / build flagsList
C2CustomizationToken architectureTier count plus tier namesCount + named tiers (e.g. 2 (primitive, semantic))
C3CustomizationTheme generatorTool that generates theme tokens from inputsNO / Basic / Advanced
C4CustomizationValue API modelHow a component's appearance is modified through CSS value classesBounded vocabulary / Open utility / Freeform / N/A
C5CustomizationRuntime customization via CSS custom propertiesTheming and behavior controllable at runtime via CSS variablesYES / PARTIAL (theming only) / NO
D1ArchitectureRendering modesMarkup shape supported by component implementationClassless-only / Mixed / Class-only
D2ArchitectureCascade layers (@layer)Documented @layer order for predictable specificityYES / PARTIAL / NO
D3ArchitectureARIA-first state expressionState expressed via pseudo-classes and ARIA attributes before custom classesYES / PARTIAL / NO
D4ArchitectureProgressive enhancementComponents render and remain accessible without JSYES / PARTIAL / NO
D5ArchitectureAuto reduced-motion adaptationFramework auto-honors prefers-reduced-motion framework-wideYES / PARTIAL / NO
D6ArchitectureAuto color-scheme adaptationFramework auto-honors prefers-color-scheme framework-wideYES / PARTIAL / NO
D7ArchitectureSpec-based component definitionEach component has a formal specification driving implementationYES / PARTIAL / NO
E1Testing & QAUnit testsPure-logic tests run by a unit test runnerYES / PARTIAL / NO
E2Testing & QAInteraction testsComponent-level interaction tests in a real browserYES / PARTIAL / NO
E3Testing & QAE2E testsFull end-to-end tests of the framework's docs / showcaseYES / PARTIAL / NO
E4Testing & QAVisual regression infrastructureVR with byte-identical (controlled-environment) rendering and committed baselinesStrict / Approximate / NO
E5Testing & QACoverage threshold enforced in CICI build fails below a coverage thresholdYES / PARTIAL / NO
F1DocumentationStructured component documentationPer-component docs with usage / accessibility / examples / API sectionsYES / PARTIAL / NO
F2DocumentationStorybook (or equivalent) playgroundsPer-component live-control playground in published docsYES / PARTIAL / NO
G1Variance & localizationComponent visual varianceHow much built-in visual variation each component supportsRich / Standard / Minimal / N/A
G2Variance & localizationi18n / RTL supportLocalization, right-to-left, locale-aware componentsYES / PARTIAL / NO
H1AI compatibilityllms.txt shippedProject ships an llms.txt discovery fileYES / NO
H2AI compatibilityMCP server shippedProject ships an MCP server for AI agent integrationYES / NO
H3AI compatibilityAgent Skills shippedProject ships Anthropic Agent SkillsYES / NO
H4AI compatibility"Copy for LLM" buttons in docsPer-page LLM-friendly copy affordance in published docsYES / PARTIAL / NO
H5AI compatibilityLLM-legibility of API surfaceBounded vocabulary, predictable naming, semantic-first markup, small surfaceYES / PARTIAL / NO
I1Lock-inMarkup portabilityConsumer's HTML stays valid and meaningful without the frameworkYES / PARTIAL / NO
I2Lock-inCustomization localityAll customization can happen in the consumer project, not upstreamYES / PARTIAL / NO
J1PositioningIndustry categoryCategory in canonical industry termsLabel
J2PositioningStarter / skeleton / white-label positioningExplicitly marketed as a starter, skeleton, white-label, or adaptive design systemYES / PARTIAL / NO

39 criteria total across 10 groups.


Detailed definitions​


Group A: Delivery​

A1. Drop-in distribution​

Measures: Whether the framework can be included via a single CDN-style stylesheet link and (optionally) a single script tag, with no build pipeline at the consumer side.

Scale: YES (CDN-style works) / PARTIAL (CDN exists but build is recommended) / NO (build pipeline required)

Why it matters: Time to first paint with no tooling investment. Determines whether the framework can be tried in a static HTML page.

Semetrika: YES - dist/semetrika.min.css + dist/semetrika.min.js per package.json main / style fields.

A2. CSS source format​

Measures: What the consumer's CSS pipeline must understand to consume the framework's source.

Scale: Vanilla CSS / Sass / Less / PostCSS / CSS-in-JS / Tailwind required

Why it matters: Removes a class of build-tooling dependency. Simpler is more portable.

Semetrika: Vanilla CSS. Lightning CSS used internally for build, but the consumer-facing source is plain CSS.

A3. JS framework requirement​

Measures: What JS framework (if any) must be present for the framework's components to render or function.

Scale: None (vanilla) / React / Vue / Svelte / Web components / Multiple supported

Why it matters: Independence from framework lifecycle and churn. Stack agnosticism.

Semetrika: None (vanilla JS). No framework required.

A4. Runtime dependency count​

Measures: Number of runtime npm dependencies (excluding devDependencies).

Scale: Count - 0 / 1-3 / 4-9 / 10+

Why it matters: Bundle size, supply-chain surface area, upgrade hygiene.

Semetrika: 1 (@floating-ui/dom only). Per package.json.

A5. License​

Measures: Open-source license terms.

Scale: Permissive (MIT, Apache 2.0, BSD) / Copyleft (GPL, AGPL, MPL) / Proprietary / paid

Why it matters: Compliance constraints, derivative-product ability, commercial integration risk.

Semetrika: Copyleft - GPL-2.0-or-later. Per package.json.


Group B: Completeness​

B1. Component scope​

Measures: Total count of named, ready-to-use artifacts across categories, broken down by type.

Scale: Breakdown - components / utilities / form controls / patterns / pages / icons (where the product breaks them out)

Why it matters: Scope you get out of the box. Differentiates "starter" from "tiny" from "full".

Semetrika: 71 components + 19 utilities + 18 patterns + 11 reference pages. Per src/components/, src/utilities/, src/patterns/, src/pages/.

B2. Iconography​

Measures: Whether the framework ships with icons - either as a built-in system, as a component-only with no pack, or via explicit integration with a third-party icon set.

Scale:

  • Built-in (system + pack) - icon component + icon library shipped together
  • Built-in (component only) - icon component shipped, but no icon pack
  • Integrated 3rd-party - explicit integration with an external pack (Iconify, Lucide, Heroicons, Font Awesome, etc.); documented but not bundled
  • NO - no icon affordance

Why it matters: Removes a separate adoption decision; matches design-language consistency. Third-party integration is a cost-conscious middle ground.

Semetrika: Built-in (system + pack) - icon component with build-sprite.js script (yarn icons). Per src/components/icon/.

B3. Server-side template parity​

Measures: Whether components ship with server-side renderable templates beyond client-side JS / web components.

Scale: YES (language: Twig / Liquid / Nunjucks / Pug / ERB / Jinja / etc.) / PARTIAL (SSR via framework's own renderer) / NO (client-only)

Why it matters: Server-first frameworks (Rails, Hugo, Eleventy, Astro server components) need template parity to use components without client-only rendering.

Semetrika: YES (Twig) - every component ships a .twig template. Per src/components/{name}/{name}.twig.

B4. Reference page templates​

Measures: Whether the framework ships full-page reference templates (not just components or patterns).

Scale: Count of full reference pages, or YES / NO

Why it matters: Adopters and AI tools see how the framework composes at full-page scope.

Semetrika: 11 reference page templates in src/pages/.


Group C: Customization​

C1. Customization surfaces​

Measures: What surfaces the framework exposes for customization.

Scale: List of: variables / tokens / components / patterns / plugins / build flags / themes

Why it matters: Tells adopters how far they can extend without forking. About what not how much.

Semetrika: variables, tokens, components, patterns - four surfaces, plus runtime options via CSS custom properties (see C5).

C2. Token architecture​

Measures: The token-tier model the framework uses, expressed as tier count plus the names of those tiers.

Scale: Tier count + named tiers. Examples:

  • 1 (primitive) - flat values only
  • 2 (primitive, semantic) - Open Props / Semetrika style
  • 3 (primitive, semantic, component) - Material / Carbon style (per Martin Fowler's three-layer model)
  • 0 - no token system

Why it matters: Predictable customization; theme switching at the right layer; LLM-comprehensible naming.

Semetrika: 2 (primitive, semantic). Primitives: --<category>-<scale>. Semantic tokens: --<target>[-<variant>][-<qualifier>][-<state>]-<concern>. Per src/variables.css and Rule 23 (docs/content/handbook/rules/23-css-tokens-and-options.md).

C3. Theme generator​

Measures: Whether the framework ships a tool that generates theme tokens (palette, typography, spacing, etc.) from a small set of inputs.

Scale:

  • Advanced - generator takes multiple inputs (brand colors + typography + spacing scale, etc.) and produces a full theme
  • Basic - generator takes one input (typically a brand color) and produces a stepped palette in a perceptual color space (OKLCH / HCT / LCH)
  • NO - no generator; consumer manually defines tokens

Why it matters: Brand-to-theme in one step instead of manual construction. Lowers onboarding cost.

Semetrika: Basic - 11-step OKLCH perceptual generator from any brand hex (one input, palette only; typography and spacing are manually defined). Per docs/src/components/PaletteGenerator/.

C4. Value API model​

Measures: How a component's appearance is modified through CSS value classes across capabilities (size, appearance, fill, shape, etc.) - i.e. the shape of the API a consumer uses to change a component's look.

Scale:

  • Bounded vocabulary - finite predefined set of value classes / words; documented; the same vocabulary applies across components
  • Open utility - infinite utility-class space (Tailwind-style); values applied as utility-class combinations
  • Freeform - no constrained model; consumer applies arbitrary classes
  • N/A - framework doesn't have classes (headless primitives, design-file UI kits)

Why it matters: Determines visual consistency over time, AI-comprehensibility, and "drift" risk across instances of the same component.

Semetrika: Bounded vocabulary - 13 capabilities documented in Rule 22 (docs/content/handbook/rules/22-css-capability-vocabulary.md) and reflected in cascade layers (src/layers.css).

C5. Runtime customization via CSS custom properties​

Measures: Whether the framework's behavior and appearance can be changed at runtime via CSS variables, without rebuilding.

Scale:

  • YES - both theming (colors, typography, spacing) AND behavior / feature flags (animations, density, rounding, loading style, etc.) can be changed at runtime via CSS variables
  • PARTIAL (theming only) - color / typography / spacing tokens work at runtime, but feature flags or behavior toggles require a rebuild (typically because they live in Sass / build config)
  • NO - all customization is build-time only (Sass variables, config file, etc.)

Why it matters: Customize on the fly per page, per route, or per user preference, without a rebuild. Important for consumer-side theming and accessibility preferences.

Semetrika: YES - both theme tokens AND runtime feature flags via --option-animations, --option-rounded-corners, --option-elevation, --option-card-elevation, --option-loading-mode. Global options are declared in src/options.css; per-component options live in the owning component's {name}.variables.css sidecar. Auto-honors prefers-reduced-motion.


Group D: Architecture​

D1. Rendering modes​

Measures: What markup shape the framework's component implementation supports.

Scale:

  • Classless-only - styles raw semantic HTML; no class-based version
  • Mixed - both classless semantic HTML and classful HTML are supported by the same component implementation, simultaneously
  • Class-only - classes required; semantic HTML alone is not styled (includes framework-bound JSX components and custom-element tags)

Why it matters: Markup portability, semantic-first authoring, exit cost.

Semetrika: Mixed - classless-first + class-based mirror, both work simultaneously, single component implementation. Per Rule 11 (docs/content/handbook/rules/11-markup-rendering-modes.md).

D2. Cascade layers (@layer) for specificity​

Measures: Whether the framework uses CSS cascade layers to control specificity.

Scale: YES (documented @layer order) / PARTIAL (some @layer use, no documented order) / NO

Why it matters: Predictable specificity; consumer overrides slot in cleanly without !important.

Semetrika: YES - 15 named layers declared in src/layers.css: base, intent, fill, size, shape, fit, layout, orientation, spacing, position, visibility, motion, surface, annotation, state. Per Rule 21.

D3. ARIA-first state expression​

Measures: Whether the framework expresses interactive state via CSS pseudo-classes and ARIA attributes before falling back to custom .is-* classes.

Scale: YES (documented order: pseudo → ARIA → custom) / PARTIAL (mixed) / NO (custom-class-only state)

Why it matters: Accessibility-first state expression; native semantic state; predictable JS hooks.

Semetrika: YES - per Rule 24 (docs/content/handbook/rules/24-css-state-and-theme.md). Tier order: pseudo-class → ARIA → .is-*.

D4. Progressive enhancement (works without JS)​

Measures: Whether the framework's components render and remain accessible when JS is disabled.

Scale: YES (documented PE model; components are accessible HTML/CSS without JS) / PARTIAL (some components need JS) / NO (JS required for any component)

Why it matters: Resilience, accessibility, SSR / static-site compatibility, search-engine indexing.

Semetrika: YES - per Rule 41 (docs/content/handbook/rules/41-js-progressive-enhancement.md). JS binds via data-* attributes.

D5. Auto reduced-motion adaptation​

Measures: Whether the framework auto-honors prefers-reduced-motion framework-wide (i.e. all components) without per-component code.

Scale: YES (one global mechanism applies to every component) / PARTIAL (some components handle it, not all) / NO

Why it matters: WCAG 2.2 compliance by default; one source of truth for motion preference.

Semetrika: YES - --option-animations automatically 0 under prefers-reduced-motion: reduce. Every component consumes the option via calc() multiplier. Per src/options.css.

D6. Auto color-scheme adaptation​

Measures: Whether the framework auto-honors prefers-color-scheme (or equivalent dark-mode mechanism) framework-wide via scheme-aware tokens.

Scale: YES (scheme-aware tokens on every component, automatic) / PARTIAL (some components themed, not all) / NO

Why it matters: Dark-mode support without per-component theming code.

Semetrika: YES - scheme-aware semantic tokens declared on :root (light) with matching overrides in a single [data-color-scheme='dark'] block; page-level data-color-scheme="dark" on <html> forces dark. Per Rule 24.

D7. Spec-based component definition​

Measures: Whether each component has a formal specification (machine-readable or structured-document) that drives implementation, rather than ad-hoc code-first definitions.

Scale:

  • YES - every component has a formal spec; deviations are caught by lint / CI / spec-matrix checks
  • PARTIAL - some components have specs; not all; or specs exist but are not enforced
  • NO - component definitions are ad-hoc

Why it matters: Predictability across components; sustainable contribution model; AI can reason about compliance; new contributors learn from specs not code.

Semetrika: YES - 19 numbered rules in docs/content/handbook/rules/ (markup 11-13, CSS 21-25, Twig 31-32, JS 41-43, project 51-53, storybook 61-63). Per-component spec requirements per Rule 53. Auto-checked via yarn cli all in lint.


Group E: Testing & QA​

E1. Unit tests​

Measures: Whether the framework has a unit-test suite for pure-logic code (helpers, plugins, build scripts) that runs in a unit test runner (Vitest, Jest, Mocha, etc.).

Scale: YES (substantive unit tests run in CI) / PARTIAL (a few tests, or non-CI) / NO

Why it matters: Catches logic bugs in helper code before integration.

Semetrika: YES - Vitest runs *.test.js files in src/ and .storybook/plugins/.

E2. Interaction tests​

Measures: Whether the framework runs component-level interaction tests in a real browser (or browser-equivalent), exercising user interactions like clicks, keyboard events, focus changes.

Scale: YES (per-component interaction tests run in CI) / PARTIAL (a few components covered, or non-CI) / NO

Why it matters: Catches keyboard-handling, focus-management, ARIA-interaction regressions before release.

Semetrika: YES - Storybook play functions in *.stories.js files run via @vitest/browser-playwright against real Chromium.

E3. E2E tests​

Measures: Whether the framework has an end-to-end test suite covering the framework's docs / showcase / sample integration as a full running site.

Scale: YES (E2E suite covers docs / showcase) / PARTIAL (limited coverage) / NO

Why it matters: Catches integration bugs the unit and interaction layers don't see.

Semetrika: YES - Playwright suite in tests/e2e/.

E4. Visual regression infrastructure​

Measures: Whether the framework runs visual regression tests with stable, reproducible diffs.

Scale:

  • Strict - VR runs in a controlled environment (Docker, fixed-version browser); byte-identical baselines committed; strict pixel diff
  • Approximate - VR runs but rendering varies by host; baselines drift; non-strict diff
  • NO - no VR

Why it matters: Consumers can trust the framework doesn't silently break visually between releases.

Semetrika: Strict - by default every run, local and CI, renders inside the pinned Playwright Docker image, so the host OS cannot change the result; SEMETRIKA_VISUAL_HOST=1 opts a run onto the host browser for spec iteration and is expected to differ. Strict-zero pixel diff: no tolerated difference is configured. Baselines co-located in __screenshots__/ per component, light + dark themes captured. CI: 4-shard matrix in the same image.

E5. Coverage threshold enforced in CI​

Measures: Whether the framework's CI fails the build below a coverage threshold.

Scale: YES (threshold enforced) / PARTIAL (coverage tracked, not enforced) / NO

Why it matters: Sustained quality; prevents silent test-suite erosion.

Semetrika: YES - default 80% threshold via CI_CODE_COVERAGE_THRESHOLD repo variable.


Group F: Documentation​

F1. Structured component documentation​

Measures: Whether each component ships with structured documentation covering recurring sections (usage, accessibility, examples, API).

Scale: YES (every component has structured docs covering at minimum usage / accessibility / examples / API) / PARTIAL (some components, or partial section coverage) / NO (no embedded structured docs)

Why it matters: Consumers (and AI) get usage guidance, accessibility notes, and API reference in context. Reduces "how do I use this?" questions.

Semetrika: YES - every component has co-located {name}.mdx per Rule 61.29. Sections: When to use / When not to use / Do / Don't / Accessibility (WCAG conformance, keyboard nav, focus indicators, screen reader notes) / Related components.

F2. Storybook (or equivalent) playgrounds​

Measures: Whether the framework's published docs include a per-component live playground with interactive controls for values × states × props.

Scale: YES (per-component playground with interactive controls) / PARTIAL (some components, or playgrounds with limited controls) / NO (static docs only)

Why it matters: Adopters and AI tools sample the full possibility space interactively.

Semetrika: YES - per Rule 61. Every component has a Playground first story (e.g. Button has 12 live controls).


Group G: Variance & localization​

G1. Component visual variance​

Measures: How much built-in visual variation each component supports through capabilities - intent (primary / secondary / danger / etc.), size, fill (outlined / solid), shape, icon-position, loading-state, and so on.

Scale:

  • Rich - many capabilities per component (e.g. button exposes intent × fill × size × icon-position × loading-state), 5+ capabilities
  • Standard - typical capabilities (size + 2-3 intents + maybe fill), 2-4 capabilities
  • Minimal - one default look, perhaps a size or two, no other capabilities
  • N/A - framework doesn't have visual components (headless primitives, token-only, utility-only)

Why it matters: Determines how much UI you can build before reaching for custom CSS. Higher variance = less custom code at the consumer side.

Semetrika: Rich - components like Button expose intent × fill × size × icon-placement × disabled × loading. Card exposes default / horizontal / accent / clickable / with-meta / with-icon / title-as-paragraph. Per src/components/{name}/{name}.stories.js.

G2. i18n / RTL support​

Measures: Whether the framework supports localization, right-to-left layouts, and locale-aware components (numbers, dates, currencies).

Scale: YES (RTL + locale-aware components) / PARTIAL (logical CSS properties only, no locale-aware components) / NO

Why it matters: Global products and government services require RTL support and localised components.

Semetrika: PARTIAL - uses logical CSS properties (margin-inline, padding-block, etc.) which adapt to direction. No locale-aware components (date pickers, number inputs use browser native).


Group H: AI compatibility​

H1. llms.txt shipped​

Measures: Whether the project ships an llms.txt discovery file at the root of its docs.

Scale: YES / NO

Why it matters: llms.txt is the emerging convention for an LLM-friendly docs index, letting AI tools fetch the right context efficiently.

Semetrika: NO at audit time. Identified as an open lever.

H2. MCP server shipped​

Measures: Whether the project publishes an MCP (Model Context Protocol) server that AI tools can connect to for component / token / pattern queries.

Scale: YES / NO

Why it matters: AI agents (Claude Code, Cursor, Windsurf, Copilot) can query the framework's API surface live, without ingesting the whole codebase.

Semetrika: NO at audit time.

H3. Agent Skills shipped​

Measures: Whether the project publishes Anthropic Agent Skills (or equivalent agent-skill packages) that bundle framework knowledge for agentic use.

Scale: YES / NO

Why it matters: Pre-packaged skills give AI agents a curated working knowledge of the framework without needing to discover everything.

Semetrika: NO at audit time.

H4. "Copy for LLM" buttons in docs​

Measures: Whether the framework's published docs include a per-page button or affordance that copies the page content as plain markdown / text optimized for pasting into an LLM context.

Scale: YES (every doc page) / PARTIAL (some pages) / NO

Why it matters: Lowers the friction of sharing docs context with an AI tool.

Semetrika: NO at audit time.

H5. LLM-legibility of API surface​

Measures: Whether the framework's architecture makes LLM output reliable, regardless of explicit AI tooling. Distinct from H1-H4 - this is the inherent legibility, not the bolt-on tooling.

Scale: YES (bounded vocabulary + canonical components + semantic-first markup + predictable token naming) / PARTIAL (some of the above) / NO (utility-class infinite space, or framework-bound JSX, or unbounded customization)

Why it matters: AI generates correct code without special integration. Foundational legibility.

Semetrika: YES - per Rule 22 (bounded vocabulary), Rule 11 (classless-first / mirror), Rule 23 (token naming convention), Rule 41 (JS as progressive enhancement).


Group I: Lock-in​

I1. Markup portability​

Measures: Whether the consumer's HTML stays valid and meaningful if the framework is removed.

Scale:

  • YES - semantic HTML survives without the framework; consumer can replace the CSS / JS layer with another framework or own code
  • PARTIAL - HTML works in some shape without the framework (e.g. utility classes still parse but don't style anything)
  • NO - HTML is framework-bound (JSX components, custom-element tags requiring runtime); removing the framework leaves nothing renderable

Why it matters: Adopter exit story. Determines whether HTML is portable to the next framework or stays valid as plain HTML.

Semetrika: YES - styles raw semantic HTML (Rule 11). HTML survives without the framework.

I2. Customization locality​

Measures: Whether all customization can happen in the consumer's project, without forking or patching the framework upstream.

Scale:

  • YES - all changes happen in consumer project (variables, tokens, classes, project CSS, component swaps via documented extension points); no upstream patches required
  • PARTIAL - most customization is project-local but some extensions require upstream changes (e.g. forking to add a variant the framework doesn't expose)
  • NO - meaningful customization requires forking or patching the framework

Why it matters: Determines whether the consumer owns customization independently or stays coupled to the framework's release cadence.

Semetrika: YES - all customization is project-level: variables, tokens, classes, project CSS, component replacement via documented extension points.


Group J: Positioning​

J1. Industry category​

Measures: What kind of thing the framework is per industry-canonical terms.

Scale: Utility framework / Classful CSS framework / Headless primitive library / Styled component library / UI kit (Figma) / Skeleton (white-label / starter) design system / Brand-specific design system

Why it matters: Sets accurate expectations; defines who the framework competes with.

Semetrika: Skeleton (white-label / starter) design system with classless-first + mirror class architecture.

J2. Starter / skeleton / white-label positioning​

Measures: Whether the framework explicitly markets itself as a starter / skeleton / white-label / adaptive design system meant to become someone's own.

Scale: YES (explicit marketing claim) / PARTIAL (implies starter via metaphor or onboarding language; not explicit) / NO (markets as a finished consumer product or as primitives)

Why it matters: Adopter expectations about depth of customization; positioning vs finished design systems.

Semetrika: YES.