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
| # | Group | Criterion | What it measures | Scale |
|---|---|---|---|---|
| A1 | Delivery | Drop-in distribution | Single CDN link / script tag, no build pipeline at consumer side | YES / PARTIAL / NO |
| A2 | Delivery | CSS source format | What the consumer's CSS pipeline must understand | Vanilla / Sass / PostCSS / CSS-in-JS / Tailwind |
| A3 | Delivery | JS framework requirement | What JS framework (if any) must be present | None / React / Vue / Svelte / Web components / Multiple |
| A4 | Delivery | Runtime dependency count | Number of runtime npm dependencies | Count (0 / 1-3 / 4-9 / 10+) |
| A5 | Delivery | License | Open-source license terms | Permissive / Copyleft / Proprietary |
| B1 | Completeness | Component scope | Total count of named components / utilities / patterns / pages | Breakdown numbers |
| B2 | Completeness | Iconography | Built-in icon system or pack | Built-in (system + pack) / Built-in (component only) / Integrated 3rd-party / NO |
| B3 | Completeness | Server-side template parity | Components ship in SSR template language (Twig / Liquid / Nunjucks / etc.) | YES (language) / PARTIAL / NO |
| B4 | Completeness | Reference page templates | Full-page reference implementations beyond components | Count or YES / NO |
| C1 | Customization | Customization surfaces | What can be customized: variables / tokens / components / patterns / plugins / build flags | List |
| C2 | Customization | Token architecture | Tier count plus tier names | Count + named tiers (e.g. 2 (primitive, semantic)) |
| C3 | Customization | Theme generator | Tool that generates theme tokens from inputs | NO / Basic / Advanced |
| C4 | Customization | Value API model | How a component's appearance is modified through CSS value classes | Bounded vocabulary / Open utility / Freeform / N/A |
| C5 | Customization | Runtime customization via CSS custom properties | Theming and behavior controllable at runtime via CSS variables | YES / PARTIAL (theming only) / NO |
| D1 | Architecture | Rendering modes | Markup shape supported by component implementation | Classless-only / Mixed / Class-only |
| D2 | Architecture | Cascade layers (@layer) | Documented @layer order for predictable specificity | YES / PARTIAL / NO |
| D3 | Architecture | ARIA-first state expression | State expressed via pseudo-classes and ARIA attributes before custom classes | YES / PARTIAL / NO |
| D4 | Architecture | Progressive enhancement | Components render and remain accessible without JS | YES / PARTIAL / NO |
| D5 | Architecture | Auto reduced-motion adaptation | Framework auto-honors prefers-reduced-motion framework-wide | YES / PARTIAL / NO |
| D6 | Architecture | Auto color-scheme adaptation | Framework auto-honors prefers-color-scheme framework-wide | YES / PARTIAL / NO |
| D7 | Architecture | Spec-based component definition | Each component has a formal specification driving implementation | YES / PARTIAL / NO |
| E1 | Testing & QA | Unit tests | Pure-logic tests run by a unit test runner | YES / PARTIAL / NO |
| E2 | Testing & QA | Interaction tests | Component-level interaction tests in a real browser | YES / PARTIAL / NO |
| E3 | Testing & QA | E2E tests | Full end-to-end tests of the framework's docs / showcase | YES / PARTIAL / NO |
| E4 | Testing & QA | Visual regression infrastructure | VR with byte-identical (controlled-environment) rendering and committed baselines | Strict / Approximate / NO |
| E5 | Testing & QA | Coverage threshold enforced in CI | CI build fails below a coverage threshold | YES / PARTIAL / NO |
| F1 | Documentation | Structured component documentation | Per-component docs with usage / accessibility / examples / API sections | YES / PARTIAL / NO |
| F2 | Documentation | Storybook (or equivalent) playgrounds | Per-component live-control playground in published docs | YES / PARTIAL / NO |
| G1 | Variance & localization | Component visual variance | How much built-in visual variation each component supports | Rich / Standard / Minimal / N/A |
| G2 | Variance & localization | i18n / RTL support | Localization, right-to-left, locale-aware components | YES / PARTIAL / NO |
| H1 | AI compatibility | llms.txt shipped | Project ships an llms.txt discovery file | YES / NO |
| H2 | AI compatibility | MCP server shipped | Project ships an MCP server for AI agent integration | YES / NO |
| H3 | AI compatibility | Agent Skills shipped | Project ships Anthropic Agent Skills | YES / NO |
| H4 | AI compatibility | "Copy for LLM" buttons in docs | Per-page LLM-friendly copy affordance in published docs | YES / PARTIAL / NO |
| H5 | AI compatibility | LLM-legibility of API surface | Bounded vocabulary, predictable naming, semantic-first markup, small surface | YES / PARTIAL / NO |
| I1 | Lock-in | Markup portability | Consumer's HTML stays valid and meaningful without the framework | YES / PARTIAL / NO |
| I2 | Lock-in | Customization locality | All customization can happen in the consumer project, not upstream | YES / PARTIAL / NO |
| J1 | Positioning | Industry category | Category in canonical industry terms | Label |
| J2 | Positioning | Starter / skeleton / white-label positioning | Explicitly marketed as a starter, skeleton, white-label, or adaptive design system | YES / 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 only2 (primitive, semantic)- Open Props / Semetrika style3 (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.