Skip to main content
skill CX Codex

sizing-units — Claude Code skill: rem, px and when to use each

sizing-units teaches the agent to pick CSS units by intent: rem for text, px for borders, relative units for containers.

MIT 437 installs ★ 197 updated 2026-10-22

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add dembrandt/dembrandt-skills --skill sizing-units -a claude-code
Open on GitHub

What sizing-units does

The skill explains that a unit declares what happens to a value when the user enlarges text. rem grows with the text, px stays fixed, % and clamp() track available space. The agent writes font sizes, button padding and control heights in rem, borders and shadows in px, and container widths in relative units. Media queries go in em to respect the browser's default font size.

Triggers on design system files, tokens, tailwind.config.* and components. Checks that controls do not clip text at 200% browser zoom per WCAG 2.2 SC 1.4.4.

What it helps with

  • pick the right unit for spacing tokens
  • fix buttons that clip text when the font size increases
  • write media queries that respect user preferences
  • set control height to scale with text
  • build a card that survives enlarged text

Example prompts for the agent

  • What unit should button padding use?
  • Write a spacing scale in tokens.css with correct units
  • Why does .card clip text at 200% font size? Fix it

How to install sizing-units

1Skills CLI (Vercel)

npx skills add dembrandt/dembrandt-skills --skill sizing-units -a claude-code

2Manually: put the files in place

~/.claude/skills/sizing-units/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/sizing-units/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about sizing-units

How to install sizing-units in Claude Code?

Run npx skills add dembrandt/dembrandt-skills --skill sizing-units -a claude-code, the file lands in ~/.claude/skills/sizing-units/SKILL.md.

What does sizing-units do?

Teaches the agent to choose CSS units by purpose: rem for text and its surroundings, px for borders and shadows, relative units for containers. Shows where to use min-height instead of height and why media queries go in em.

Why does sizing-units recommend em for media queries?

em in a media query follows the browser's default font size: a user with a large default gets the mobile layout earlier than a px breakpoint would trigger, so text does not break the design.

Source text

SKILL.md · MIT
---
name: sizing-units
description: rem, px or relative units for each kind of value. Use when defining spacing and sizing tokens, control heights or media queries, or when a layout breaks under enlarged text.
metadata:
  priority: 5
  pathPatterns:
    - "design-system/**"
    - "ui/**"
    - "**/tokens*"
    - "**/*.css"
    - "**/tailwind.config.*"
    - "components/**"
    - "src/components/**"
  promptSignals:
    phrases:
      - "rem"
      - "px"
      - "em"
      - "spacing scale"
      - "sizing tokens"
      - "root font size"
      - "text zoom"
      - "which unit"
retrieval:
  aliases:
    - px vs rem
    - css units
    - spacing units
    - sizing tokens
    - root font size
    - text scaling
  intents:
    - decide between px and rem for spacing
    - define a spacing scale
    - fix a layout that breaks when text is enlarged
    - choose units for media queries
    - set control heights that survive text scaling
  examples:
    - should spacing be in rem or px
    - our buttons clip when the user enlarges text
    - what unit for border radius and shadows
    - should media queries use px or em
---

# Sizing Units

## The Question the Unit Answers

A unit is not a formatting preference. It is a declaration of what happens to a value when the user enlarges text.

- `rem` — this value belongs to the text and must grow with it.
- `px` — this value belongs to the screen and must stay put.
- `%`, `fr`, `ch`, `clamp()`, `min()` — this value belongs to the available space.

Pick the unit by answering that question, not by picking a house style and applying it everywhere. Both absolutist positions — all-rem and all-px — produce defects, and they are different defects.

## Zoom Is Not the Font-Size Setting

The common argument for px everywhere is that browsers already have full-page zoom, so the root font size can be ignored. They are separate controls serving separate people.

- **Full-page zoom** magnifies everything, layout included. It buys larger text at the cost of horizontal scrolling and fewer items per screen.
- **The browser's default font size** enlarges text and leaves the layout alone. This is what a user with low vision sets once, years ago, and never touches again. They will not switch to zoom because your product ignored it.

A product that hard-codes every dimension in px answers the first user and silently refuses the second. WCAG 2.2 SC 1.4.4 (Resize Text) requires text to reach 200% without loss of content or function, and SC 1.4.10 (Reflow) requires the page to survive it in a single column. See [[wcag-accessibility]].

## Use rem For

**Typography.** Every font size and line height. See [[modular-scale-typography]].

**Padding around text.** A button's inner padding in px means large text presses against its edges. In rem the breathing room scales with the words it surrounds.

**Control heights.** A 40px control holding 24px text is broken. Write the height token in rem and it stays a control-shaped control at every text size. See [[component-family-consistency]].

**Measure.** `max-width` on a text column: `65ch` or a rem value, never px.

**Gaps between text-bearing blocks.** Stack spacing in a form or an article is part of the reading rhythm.

## Use px For

**Hairlines and borders.** `1px` is one device pixel by intent. In rem it becomes `1.25px` at a larger root size and renders as a blurry smear.

**Shadow offsets and blur.** Elevation is a screen-space effect. See [[elevation-and-depth]].

**Small icons inside controls** where the icon is a fixed glyph rather than text.

**Sub-pixel corrections** — the `-1px` that makes two borders overlap instead of doubling.

## Use Relative Units For

Layout widths and gaps. This is where the "lock it in px so it stays stable" instinct goes wrong: a px-locked container is not stable, it is brittle. The text inside it still grows, and a fixed box is exactly what makes growing text clip.

```css
/* Brittle — the box cannot absorb anything */
.card   { width: 320px; height: 180px; }
.sidebar { width: 280px; }

/* Resilient */
.card    { max-width: 20rem; min-height: 11.25rem; }
.sidebar { width: clamp(16rem, 22%, 22rem); }
```

**`min-height`, never `height`,** on anything containing text. A fixed height cannot grow; a minimum height holds the shape at rest and yields when it must.

## Media Queries

Use `em` in media queries. Media-query `rem` and `em` both resolve against the browser's default font size, ignoring any `html { font-size }` you set — so `em` is the honest spelling, and both respect the user's preference where a px breakpoint does not. A user with a large default font size gets the layout their effective text size warrants, not the one their device width claims.

```css
@media (min-width: 48em) { /* ~768px at default settings */ }
```

## Do Not Reset the Root

```css
html { font-size: 62.5%; } /* Do not do this */
```

The 62.5% trick exists to make rem arithmetic easy — `1.6rem` for 16px. It buys you mental arithmetic and pays for it by overriding the user's stated preference by default. Keep the root at the browser default and let the tooling do the division.

## A Measured Container Must Not Depend on What It Sizes

When script sizes an element from its container, the container's size must be definite and independent of that element on every breakpoint. If the container shrink-wraps the child, the measurement reads the child's own collapsed size and the element stays collapsed, silently, on the breakpoints where the chain loses its definite size. Give the chain a definite size down to the measured box and observe the box itself, not window events.

## Review Checklist

- [ ] Is every font size, line height, and text-adjacent padding in rem?
- [ ] Are borders, hairlines, and shadow offsets in px?
- [ ] Does any element containing text use `height` rather than `min-height`?
- [ ] Are container widths relative (`%`, `fr`, `clamp()`, `max-width`) rather than fixed px?
- [ ] Are media-query breakpoints in `em`?
- [ ] Is `html { font-size }` left at the browser default?
- [ ] At a 200% browser font-size setting, does every control still contain its label, with no clipping and no horizontal page scroll?
- [ ] Is every script-measured container sized by layout rather than by the child it sizes?

© dembrandt · MIT · dembrandt/dembrandt-skills

Similar skills

All skills for Frontend and UI →

From the same set45

The whole set →
coordinated-data-views coordinated-data-views — a coding-agent skill that explains how to show a table next to its map, diagram or chart and keep selection synced both ways. CX Codex +1 843installs tab-navigation tab-navigation — a skill for designing tabs: when they fit, how the strip and panel are built, and how keyboard navigation should behave. CX Codex +1 842installs authentic-product-representation authentic-product-representation enforces truthful product visuals on landing pages and hero sections using real data instead of lorem ipsum. Use it to avoid synthetic marketing chrome. CX Codex +1 831installs domain-expert-configuration domain-expert-configuration is a Claude Code skill that guides settings panel design for people who know the problem domain but not the codebase. It activates on prompts about configuration, constraints or solver settings. CX Codex +1 830installs app-shell app-shell is a Claude Code skill with design guidelines for top bars, app switchers, tenant indicators, and status bars. It keeps navigation consistent across internal tools and customer portals. CX Codex +1 504installs clone-website clone-website rebuilds a live page into Figma, Penpot or code with verification. Captures renders, styles and content from a real browser, assembles the layout section by section, and checks the result against the original. CX Codex +1 411installs surface-separation surface-separation — a skill that teaches the agent to separate cards, panels and containers by one method — border, shadow or fill — and reserve opacity for states. CX Codex +1 378installs marketing-vs-product-system marketing-vs-product-system separates brand token foundations from surface-level UI decisions when a marketing site and a product app share one codebase. CX Codex +1 373installs

Project sponsors

Companies that keep this analytics open