An agent skill + a CLI · one unit, every window

/fluid-design

Your designer draws the desktop page on one frame: 1440×900, or whatever size they picked. A normal build is exact at that size and wrong everywhere else: cramped at 1280, floating at 2560, off the bottom of a 700-tall laptop. fluid-design writes every drawn number as number × one unit, 1px at your frame, so the page is a proportional copy of the design at every window size.

# that's the whole start /fluid-design make this landing page match our Figma desktop frame at every laptop size

runs onClaude CodeCodexCursorAntigravityopencodeGrok BuildHermesgeneratesTailwind v4CSSSCSSStyleXtested onNext.js

Tested on Next.js only, for now. Built and tuned on a production Next.js + Tailwind v4 site. The other stacks and frameworks generate correctly and pass the pack's tests, but no production site runs on them yet.

One design, many windows

Your design is drawn at one size. People open it at every size.

hand-typed pixelsfluid-design
1280×800a smaller laptop
Squeezed: the heading wraps, the picture is cut off
Same design, a little smaller
2560×1440a big monitor
Lost: small in a sea of empty space
Same design, bigger
1440×700a short window
Cut off: the button is below the fold
Fits one screen, still uses the full width
375 → 430phones
Tight on a small phone, loose on a big one
The same phone design on every phone
1024×900a 3-line heading
7 lines
The heading more than doubles
4 lines
One extra line, the layout holds

Measured on the production marketing site this skill came from. Details: fluid-scale.md §1.

The unit: n × --fluid

--fluid is 1px at your design frame (the artboard: the frame the designer draws in) and grows and shrinks with the window, following whichever axis is tighter. Write every drawn number times the unit and the whole page scales by one factor, keeping the design's proportions. No clamp() pair per property to keep in sync.

--fluid = max( 0.58, min( W / 1440, H / 900 ) )
W / 1440 the window's width against the frame's H / 900 the same for height, in svh min() the tighter one wins: always fits 0.58 --fluid-desktop-scale-min no ceiling --fluid-desktop-scale-max unset 1440 · 900 your frame, the default you can change
Tailwind v4lg:fluid-py-120
CSScalc(120 * var(--fluid))
SCSSfd.fluid(120)
StyleXfluid(120)

Six windows, one rule: the smaller ratio wins

Divide the window's width by 1440 and its height by 900. The smaller number becomes --fluid, so the design always fits. These are real fluid explain runs at the default 1440×900 frame.

windowwidth ÷ 1440height ÷ 900--fluida hero drawn 900 tall
1440×9001.00001.00001.0000900px, exactly as drawn
1280×8000.88890.88890.8889800px, fills the screen
1440×7001.00000.77780.7778700px, fills the screen
1024×9000.71111.00000.7111640px, shorter than the screen because the width is tighter
1920×10801.33331.20001.20001080px, fills the screen
2560×14401.77781.60001.60001440px, fills the screen

Six things to know

Your design frame sets the scale

The 1440 and 900 in the formula are the desktop frame your designer draws on in Figma, Sketch, Penpot or any design app. Put that frame's size in your :root and the unit is 1px there. Read every size off the design; the defaults are only fallbacks. A 1680×1050 desktop frame works the same way, and a phone frame drawn 402 wide (iPhone 16 Pro) is 402, not 390.

from the design filesetting in your :rootdefault
the desktop frame's width × height--fluid-desktop-base-width / --fluid-desktop-base-height1440 × 900
the content box's max width, side margins included--fluid-desktop-container-width1680
the side margin--fluid-desktop-container-padding80
the phone frame's width--fluid-phone-base-width390

a 1680×1050 frameyour :root

:root { /* the Figma frame */ --fluid-desktop-base-width: 1680; --fluid-desktop-base-height: 1050; --fluid-desktop-container-width: 1680; }
  • At a window exactly the frame's size, 1 drawn px = 1 CSS px. Every other window gets min(W / base-width, H / base-height).
  • The container width is in drawn px and scales with the unit. Its cap only shows on a window wider than the frame's shape, where the design is centred. Set it to the frame's width, or narrower if the design caps its content.
change it → nothing to run: live, no regenerate

setting itonce, at init

$ fluid init --desktop 1680x1050
  • Without the flag, fluid init asks: Desktop design frame, width x height (1440x900).
  • Or edit the two variables later.
  • The default container of 1680 lets a 1440 design spread a little wider on wide windows.

The base is your Figma frame, nothing else. “Base” just means the size of the desktop frame you measure from. Example: the designer draws on a 1680×1050 frame, with a 48px heading. Set the base to 1680×1050, type 48, and this is what the browser shows:

browser windowthe 48px heading renders at
1440×90041px smaller window, scaled down
1512×982 14″ MacBook Pro43px
1680×1050 same as the frame48px exactly as drawn
1920×108049px capped by the height

Forgot to set the base? It stays at the 1440×900 default, so a 1680 design comes out 17% too big at every window (the 48px heading is 56px on a 1680 screen).

Rare case: the designer put a 1440 layout in the middle of an extra-wide 1680 canvas. Measure the layout, not the canvas: base 1440×900, and --fluid-desktop-container-width: 1680. That is what the defaults already are.

Follow the height, or only the width

On desktop the unit also watches the window's height, so a section drawn 900 tall always fits one screen. One setting turns that off, and the page follows the width only. It applies live, like every setting. Try it with the follow the height switch in the demo.

:root { /* 1 = also fit the height (default) */ --fluid-desktop-fit-height: 0; }
window (frame)height on: 1, defaultheight off: 0
1440×700 (1440×900)0.78×, the 900-tall hero fits the screen1×, the hero is 900px and scrolls
2000×1013 (1680×1050)0.96×, the page shrinks to the height and leaves side margins1.19×, the page fills the width
pick it forsections drawn to fill one screen: a hero, a pinned scroll scenepages where nothing has to fit one screen

Phones, tablets and landscape always follow the width only. Height never squashes text: it scales the font size and the line height by the same number. If lines look cramped after a change, hard-reload first, because a stale stylesheet looks exactly like broken spacing.

Try it: the real engine, in a frame

The frame below is a small page drawn once at 1440×900 and once at 390, written only as drawn number × unit through the pack's own generated fluid.css (the CSS stack at the defaults, copied byte for byte). Pick a window, drag the corner, or switch off follow the height. The readout is measured inside the frame, next to what fluid explain prints for the same window.

active banddesktop
variablein the framefluid explain
multipliers
--fluid1.00001.0000
--fluid-display1.00001.0000
--fluid-copy1.00001.0000
--fluid-ui1.00001.0000
sizes, in px
--fluid-container-width1680.01680.0
--fluid-container-padding80.080.0
--fluid-header-h72.072.0
At the design frame every unit is exactly 1: one drawn px is one CSS px.
The fluid explain column is what the CLI prints for the seven presets; it turns green where the frame agrees. At any other size only the live column updates.

The demo's widest drawn row is 600 + 120 + 560 = 1280, and fluid calc budget --widths 600,120,560 says PASS, 0px to spare inside the 80-padding container. At 1440×700 the hero is 700px tall, at 2560×1440 it is 1440: the dashed dimension line on its right edge always spans the window.

Four bands, each scaling its own design

A band is a range of window sizes with its own design: phone, tablet, landscape (a phone on its side) and desktop. Each has its own frame size, its own min and max for the unit, and its own type damping. You write the phone numbers once for every mobile band and the desktop numbers from lg: up; only the unit changes between bands. No redraw per breakpoint.

phone

fluid-phone:
Portrait phones. The unit follows the width against the 390 frame.
base width390
unit min0.82
unit max1.1
display damping0.85
copy damping0.6
container560
padding24

tablet

fluid-tablet:
600px and wider: the phone design, scaled up, running full width.
base width700
unit min1.1
unit max1.3
display damping0.85
copy damping0.6
container1024
padding32

landscape

fluid-landscape:
A phone on its side, 500 tall or less: the phone design, scaled a bit, full width and clear of the notch.
base width780
unit min1
unit max1.2
display damping0.85
copy damping0.6
container1024
padding32

desktop

lg:
1024px and wider. Both axes against your frame: min(W/1440, H/900) at the default.
base1440×900
unit min0.58
unit maxnone
display damping0.62
copy damping0.33
container1680
padding80

Every number above is a default you can set (--fluid-desktop-base-width, --fluid-tablet-scale-max, --fluid-phone-container-padding…), and a default is a fallback for a band the design has no frame for. No tablet or landscape frame is the normal case: the container width defaults to the desktop breakpoint (wider than any window in those bands), so the phone design runs full width with a 32 gutter instead of floating in a phone-sized column. Want the old 560 column? Set --fluid-tablet-container-width: 560 and --fluid-tablet-container-padding: 24 (same for landscape). Keep --fluid-tablet-scale-min equal to --fluid-phone-scale-max so nothing jumps at 600.

The band variants are exclusive, and never mix one with sm:/md: on a property: band variants sort after every breakpoint, so they always win. Have a separately authored mobile layout? bands.phone: false (or fluid init --no-mobile) keeps a flat 1px below desktop.

Type roles: type shrinks less than the layout

A heading shares its column with fixed measures, so type should shrink more gently than the layout. A type role is a size curve for that: --fluid-display for headlines, --fluid-copy for body and labels, plus any role you add (caption). Damping is how much a role shrinks with the layout: 1 shrinks as much as the layout, 0 never goes below its drawn size. Above the design frame, roles grow with the unit one to one. Plotted from the engine's formula at the desktop defaults:

Chart: type scale factor against the layout unit on the desktop band. The layout unit is the diagonal. Display type (damping 0.62) and copy type (damping 0.33) sit above it below 1, hold their size below 0.711 (a 1024-wide window's unit) at 0.821 and 0.905, and match the unit above 1. 0.60.81.01.2 0.60.81.01.2 --fluid (the layout unit) type holds · 0.711 = 1024 / 1440 floor copy 0.905 display 0.821 layout 1440×900: all = 1
--fluid · layout--fluid-display · damping 0.62--fluid-copy · damping 0.33type holds its size below here
--fluid 0.7778 (1440×700) → a drawn 64 heading renders 55.2px on display, 18 copy renders 16.7px, a 120 padding is 93.3px

--fluid-display = max(--fluid, d · max(--fluid, knee) + (1 − d)), where d is the damping and the knee is the unit at the desktop breakpoint (1024 / 1440 = 0.711 with the default frame). Below it, type holds its size: on a short desktop window the layout keeps shrinking toward 0.58 so the section still fits, while headings stay readable.

the text sits in…usewhy
a fixed column beside fixed measuresfluid-display-*damped: shrinks less than the layout, so the line count holds
a box that scales with the layout (a card, a figure)fluid-text-*the base unit, blended toward the zoomed one for browser zoom
small labels and controlsfluid-copy-*damped harder (0.33): barely shrinks at all
the header, nav and footerfluid-ui-*follows the width, never shrinks for a short window
a button, chip or icon around a labelfluid-copy-h-56 fluid-copy-px-24the box uses the label's role, so the two keep their proportion. Every role has -h -w -size -p -px -py -gap

--fluid-uisite chrome

The header row and nav follow the width, and height never pulls them below the design point, so the nav stays usable on a short laptop. --fluid-header-h is built from it.
1440×700: --fluid 0.78, --fluid-ui 1.00 · 1024×900: 0.71 and 0.71 (the nav still has to fit) · 2560×1440: 1.60 and 1.60

browser zoomWCAG 1.4.4

Viewport units do not grow with Cmd/Ctrl +. A small runtime measures the zoom and type reads --fluid-z, so text still zooms 1:1 while the layout keeps fitting.
One head script: Next <FluidHead />, Vite fluidPlugin(), or zoom.classic.js. Under a strict CSP pass a nonce, or allow FLUID_ZOOM_SHA256.

Limits, scopes and the container

Sometimes part of a page should stop scaling: a header that stops growing past a 1680 window, a panel that never shrinks below its 1280 size, a widget that should not scale at all. That is a limit: one utility on the element, in window px. It makes the element a scope (part of the page with its own settings), and every fluid-* class inside follows. On a tall window, where width is the tighter axis:

Chart: the layout unit against window width from 1024 to 2560. Default: a straight line from 0.711 to 1.778. fluid-grow-until-1680 flattens at 1.167 past a 1680 window. fluid-shrink-until-1280 holds 0.889 below a 1280 window. fluid-off stays at 1. 102412801440168019202560 0.81.01.21.41.6 window width (CSS px) grow-until-1680 → 1.167 shrink-until-1280 → 0.889 fluid-off → 1
defaultfluid-grow-until-1680fluid-shrink-until-1280fluid-off

fluid-grow-until-1680

Units stop growing: they keep the size they had at a 1680 window. Writes --fluid-grow-until: 1680.

fluid-shrink-until-1280

Units stop shrinking below their 1280 size. Overrides fit-height, so use it on components, not one-screen sections.

fluid-ui-grow-until-1680

Only --fluid-ui stops growing. For the site header, set it on :root so --fluid-header-h holds with it.

fluid-off

Nothing scales inside: one drawn px is one CSS px. Browser zoom still works.

fluid-containerone per section

  • The page wrapper. Max width and side padding come from the active band: 1680 / 80 on desktop (set from your frame), 560 / 24 on phones, full width with 32 on tablet and landscape.
  • The padding never drops below the safe-area inset, so a phone on its side under viewport-fit=cover keeps content clear of the notch with no extra rules.
  • The max width only grows: at 2560×1440 it is 2688px, never narrower than 1680 CSS px.
  • Apply it once per section, on the section's inner wrapper. A text measure sits inside it and never replaces it.
  • fluid-bleed-x inside it reaches the window's edges and pads back in, so a carousel track runs edge to edge while its content lines up with the container.
  • Changing the gutter later is one setting: --fluid-desktop-container-padding: 108 widens every section at once.

the content budgetcheck before building

$ fluid calc budget --widths 600,120,560 row: 600 + 120 + 560 = 1280 budget at the design frame: min(base-width 1440, container-width 1680) − 2 × padding 80 = 1280 PASS — 0px to spare.
  • A row over budget needs a redrawn row or widths taken from the container (cqw, or a fixed drawn max width). A smaller padding never fixes it.

Structure vs settings

There are two places to configure, and every option lives in exactly one of them. You never set the same thing twice. Most changes are numbers, and numbers go in your CSS :root only: the JSON file is not touched and nothing has to run.

you want to changeeditthen
frame sizes, gutters, container width, how far the scale shrinks or grows, type damping, limits, height on or off:root in your CSSnothing, it applies live
where a band starts (the tablet or desktop breakpoint), or turning a band on or offfluid.config.jsonfluid generate
adding a type role ("caption"), the ui or zoom unit on or off, Tailwind options, the class prefix, the stack or output folderfluid.config.jsonfluid generate

The JSON decides which CSS rules exist, so changing it means regenerating. The :root variables are the numbers inside those rules. Here is what fluid init wrote for a Next + Tailwind v4 project:

fluid.config.jsonstructure

{ "$schema": "https://unpkg.com/fluid-design-cli@2/skills/fluid-design/assets/fluid.config.schema.json", "version": 2, "bands": { "phone": true, "tablet": { "minWidth": 600 }, "landscape": { "maxHeight": 500 }, "desktop": { "minWidth": 1024 } }, "output": { "integration": "next" } }
  • Which bands exist and their breakpoints, the role names (add "caption"), the prefix, ui and zoom on or off, the output stack and folder.
  • Your editor validates it against the published schema; no copy lands in your project.
  • output.editor: true also writes the VS Code settings autocomplete and a settings.reference.css.
change it → fluid generate (or keep generate --watch running)

your :root43 settings

@import 'tailwindcss'; @import '../styles/fluid/fluid.css'; :root { --brand: #796100; /* fluid settings: `npm run fluid -- settings` lists every one with its default */ --fluid-phone-scale-min: 0.8; --fluid-desktop-display-damping: 0.7; --fluid-desktop-scale-max: 1.4; }
  • Frame sizes, unit min and max, damping per band and role, the container, header heights, limits, the zoom text range.
  • An invalid value falls back to its default; fluid check flags a typo with a suggestion. fluid settings lists them all.
change it → nothing to run: live, no regenerate

One import brings the units, the settings, the base layer, the breakpoints, the band variants and the utilities. Everything is generated into one folder (src/styles/fluid/ by default): fluid.css, base.css, fluid.ts, cn.ts / _index.scss / fluid.stylex.ts, runtime/, integrations/ and a plain-words README.md. The decisions are logged in a short FLUID.md. Every key and setting with its default: config.md.

The fluid CLI

The skill drives one CLI, and so can you. A real session in a fresh Next + Tailwind v4 project, then a live check of this page's own demo frame (served locally, checked from a CSS-stack project, the stack the frame uses):

$ fluid init --yes ✓ fluid.config.json (tailwind-v4, next) ✓ src/styles/fluid: 11 files (11 changed) · build 2.1.0+174db8f4 ✓ src/app/globals.css: added @import '../styles/fluid/fluid.css';, and a commented settings starter in your :root ✓ package.json: "fluid" script (npm run fluid -- check · explain 390x844 · settings · generate) Browser zoom: app/layout.tsx: import { FluidHead } from '…/src/styles/fluid/integrations/next' → <head><FluidHead /></head>
$ fluid check ✓ generated files match fluid.config.json ✓ settings: nothing to flag OK
$ fluid explain 1440x700 1440×700 → desktop: 1024px and wider: your desktop design frame (default 1440×900) --fluid 0.7778 100 drawn px = 77.8 CSS px --fluid-display 0.8622 64 drawn px = 55.2 CSS px --fluid-copy 0.9267 64 drawn px = 59.3 CSS px --fluid-ui 1.0000 --fluid-container-padding 62.2px settings in play (desktop): --fluid-desktop-base-height 900 default --fluid-desktop-display-damping 0.62 default …
$ fluid explain 1440x700 --url http://127.0.0.1:4391/demo/ --brief --fluid page 0.7778 expected 0.7778 --fluid-display page 0.8622 expected 0.8622 --fluid-copy page 0.9267 expected 0.9267 --fluid-ui page 1.0000 expected 1.0000 ✓ OK: the page's units match (worst drift 1.2e-5)
commandwhat it does
initasks the design questions (or takes flags), writes the config, generates, wires the import, your settings and the fluid npm script
generate [--watch]writes the output folder from the config; refuses to overwrite a hand edit; CRLF- and formatter-safe
checkthe CI gate: config, generated files, settings lint, source rules
settings [--json]every setting with its default (what you can put in your :root)
explain WxHevery unit at a viewport and where it came from; --url for the live page, its verdict and every scope
probe <url>a one-shot freshness verdict
migrate [--write]moves a v1 config to v2
calc · verify · auditmaths tables and the content budget · the Playwright viewport matrix with a real browser-zoom row · the static source audit

Four stacks, one set of units

Every stack spends the same custom properties, defined once in the generated fluid.css; only the authoring surface differs. The same hero, four spellings:

<section class="fluid-py-48 lg:fluid-py-120 lg:fluid-h-900"> <div class="fluid-container"> <h1 class="fluid-display-40/44 lg:fluid-display-64/72">…</h1> <p class="fluid-copy-16/24 lg:fluid-copy-18/28">…</p> <a class="fluid-copy-h-56 fluid-copy-px-24 fluid-copy-14/20">…</a> </div> </section>

The phone number unprefixed, the desktop one behind lg:. Bare numbers in 0.25 steps, anything else bracketed (fluid-p-[8.3]); /lh is drawn px, not a ratio. The button's box reads the same role as its label, so the two scale together. Components that take className need a cn that knows the fluid classes: keep yours and extend it with withFluid.

what you getTailwind v4CSSSCSSStyleX
the units, settings and fluid-container✓✓✓✓
fluid-* utilities for every spacing, size and type family, and box sizes on each type role✓——functions—helpers
fluid-bleed-x: an edge-to-edge strip aligned with the container✓✓class✓mixin✓class
band variants fluid-phone: fluid-tablet: fluid-landscape:✓—✓mixins—
class merging (cn.ts, withFluid) + IntelliSense✓———
a build error on 64px * unit——✓✓typed
fluid.ts: DESKTOP_QUERY, MEDIA, fluidPx() for motion code✓✓✓✓
tested on a production site✓Next.js—tests only—tests only—tests only
browser floorTailwind v4's ownSafari 15.4 · Chrome 108 · Firefox 101

fluidPx(n, unit, el) turns a drawn number into CSS px at an element, limits included, for GSAP or Motion distances. Tailwind 3 cannot run functional utilities: fluid init picks the CSS stack and recommends the upgrade.

Verification and proof

The engine is plain CSS, so it is tested in real browsers against an independent JS model of the maths, not by reading the stylesheet. The numbers below come from the repository's suites, re-run for this page:

19,554checks0 failures: every band, limit and config variant against the model in Chromium, WebKit and Firefox (tests/engine-matrix.mjs)
7,548checksthe SCSS module's functions, band and limit mixins, compiled by real Sass and measured in three browsers (tests/scss-browser.mjs)
8.86msper resize step in WebKit on a 2,000-element page spending the units (5.31 in Chromium); CI guards that 50 limit scopes cost at most 1.6× (tests/resize-perf.mjs)
3OSesCI runs the zero-browser suite on Ubuntu, macOS and Windows, and the real-browser suites in Chromium, WebKit and Firefox
15.4the Safari floor on the CSS, SCSS and StyleX stacks, with Chrome 108 and Firefox 101; Tailwind's is Tailwind v4's own
18referenceseach rule records the bug it prevents and the measurement behind it, from a production marketing site

And in your project, the same gates the skill runs before it calls the work done:

fluid checkConfig, generated files, settings lint and source rules. Resolve every error and every warning; put it in CI.
fluid audit srcA static scan for the silent failure modes: dvh on scaled boxes, a limit on children, a /1.5 line-height ratio.
fluid verify <url> --screensWidths 1024–2560 × heights 640–1440 plus the phone, tablet and landscape set: horizontal overflow, every unit against the maths, one-screen fit, grid column counts, and a real browser-zoom row. Again with --browser webkit and --browser firefox.
your frame, pixel for pixelThe calibration point: at the frame's own size (1440×900 by default) the page must match the design exactly.
a real deviceThe iOS toolbar tint, the lvh shortfall and safe areas can only be verified on a phone. The skill reports this gate as open rather than claiming it.

Pick by job

The skill triggers on what people say, even without the word "fluid". Its SKILL.md is a router: preflight first, then only the references the task touches.

All eighteen, grouped by when you need them:

before any code2
preflight.mdalways first: stack, design frames, bands, container, roles, ceiling, zoom, each with a default and a detection hint config.mdgenerated: every structure key and setting with its default
the model6
fluid-scale.mdthe base unit: drawn number × unit, the two axes, the design frame, the ceiling units.mdtype roles and damping, the ui unit, the header height, the container units bands.mdphone, tablet, landscape, desktop: switches, continuity, full width limits-and-scopes.mdone scale per page; limits and scopes browser-zoom.mdWCAG 1.4.4: the head script, CSP, detection, the handover contract.mdthe checked vocabulary: browser floor, utilities, fluid.ts exports, what motion code reads
build a section6
section-recipe.mdthe per-section checklist and shipped anatomy frame-and-gutter.mdone container per section, the content budget, cqw escapes typography.mdthe type unit per text element, /lh, em tracking, fonts media.mdimages, inline SVG and <video> sized and reserved in fluid units tokens-and-theming.mdwhere tokens live beside the settings, and the traps that compile clean stacks.mdTailwind v4, CSS and CSS Modules, SCSS, StyleX
an existing site1
brownfield-migration.mdfluid migrate, route-by-route conversion, keeping an existing cn
survive the browser2
ios-safari.mdsvh/lvh/dvh, safe areas, the iOS 26 toolbar tint, sticky killers performance.mdthe render budget: resize cost, image sizes on a page that grows, fonts
prove it1
verification.mdthe tiers, the viewport matrix cell by cell, the stale-stylesheet diagnosis

Start here

Three ways in, one CLI. An agent runs it for you; a developer can run it by hand, with or without Node.

an agentClaude Code, Codex, Cursor…

Install the skill, then ask for what you want. It runs a short preflight and calls node <skill>/bin/fluid itself.
npx skills add gabros20/fluid-design-skill

a Node projectno install

The same CLI from npm. init detects your stack and framework and asks the design questions.
npx fluid-design-cli@2 init

no NodeRails, Django, Laravel, Hugo…

A standalone fluid binary for Phoenix, plain HTML and anything else. Windows: install-cli.ps1.
curl -fsSL https://raw.githubusercontent.com/gabros20/fluid-design-skill/main/install-cli.sh | sh fluid init
# or: clone + installer (per-host targets) git clone https://github.com/gabros20/fluid-design-skill && cd fluid-design-skill ./install.sh claude # or: codex | agents | cursor | antigravity | opencode | grok | hermes | all # then ask /fluid-design make this landing page match our Figma frames at every laptop size /fluid-design convert this Tailwind site to fluid scaling /fluid-design the hero doesn't fit on a 13-inch laptop and the header is huge on 5K

The same install runs on any Agent Skills host. Codex installs to ${CODEX_HOME:-$HOME/.codex}/skills; agents remains a separate cross-agent target. If a project already uses one of the three channels, the skill uses it instead of installing a second.

install targets by host
hostinstall targetcommand
Claude Code~/.claude/skills./install.sh claude
Codex${CODEX_HOME:-$HOME/.codex}/skills./install.sh codex
Cross-agent path~/.agents/skills./install.sh agents
Cursor CLI~/.cursor/skills./install.sh cursor
Antigravity (IDE + agy)~/.gemini/…/skills./install.sh antigravity
opencode~/.config/opencode/skills./install.sh opencode
Grok Build~/.grok/skills./install.sh grok
Hermes~/.hermes/skills./install.sh hermes

Prefer npx skills add gabros20/fluid-design-skill when you have Node: it maps supported clients itself.

what's in the repo
skills/fluid-design/ the skill: SKILL.md (router) · references/ · bin/fluid · scripts/ · assets/ assets/styles/ reference output per stack at the defaults: tailwind-v4 · css · scss · stylex assets/runtime/ fluid-units.js (fluidPx) · fluid-zoom.js docs/ installation · usage (the by-hand guide) · recipes · cli-internals examples/ pizza-next (Next + Tailwind v4) · pizza-vite-gsap (Vite + SCSS + GSAP) tests/ engine matrix · SCSS in the browser · Tailwind compile · resize perf site/ this page; demo/ holds the live frame and a copy of the engine install.sh · install-cli.sh · install-cli.ps1 README.md · CHANGELOG.md · LICENSE

More docs: docs/installation.md · docs/usage.md · docs/recipes.md.

What it is, and what it isn't

This skill makes the page the right size. It contains no animation. So far it runs in production on Next.js + Tailwind v4 only; other setups pass the tests but have no live site behind them yet.

fluid-design

  • "Match our Figma frame at every laptop size", "fit one screen"
  • "The page floats on 2560", "the header is huge on 5K"
  • "The hero doesn't fit on a 13-inch laptop"
  • Converting an existing site, or a v1 fluid-design project
  • What the scale has to survive: iOS Safari viewports, media sizing, browser zoom, a stale stylesheet

not this skill

  • A breakpoint ladder with clamp() type (Utopia-style "make it responsive"): a different model, one pair per property.
  • A colour system or a component library. The tokens reference covers only where tokens live next to the settings and the traps that compile clean.