Skip to content
Skills Library
Design & UX · Building & coding

responsive-breakpoints

/responsive-breakpoints

Framer-style responsive breakpoint editing in Design: one DOM tree per screen with cascading width-scoped overrides. Use when adding/removing breakpoints, editing a design at a specific device width, resolving which value renders at a width, or persisting responsive style changes.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Framer-style responsive breakpoint editing in Design: one DOM tree per screen with cascading width-scoped overrides. Use when adding/removing breakpoints, editing a design at a specific device width, resolving which value renders at a width, or persisting responsive style changes.

Original author description

Framer-style responsive breakpoint editing in Design: one DOM tree per screen with cascading width-scoped overrides. Use when adding/removing breakpoints, editing a design at a specific device width, resolving which value renders at a width, or persisting responsive style changes.

How it works

  1. Managing breakpoints
  2. Editing responsively (agent parity)
  3. Resolving and inspecting overrides
  4. Cautions
Original SKILL.md headings · 102 lines, 675 words
SKILL.md preview
---
name: responsive-breakpoints
description: >-
  Framer-style responsive breakpoint editing in Design: one DOM tree per
  screen with cascading width-scoped overrides. Use when adding/removing
  breakpoints, editing a design at a specific device width, resolving which
  value renders at a width, or persisting responsive style changes.
---

# Responsive Breakpoints

Design uses the **Framer model**: every screen is ONE document (one DOM
tree). Breakpoint frames are the SAME document rendered at different
viewport widths — never separate copies. Edits cascade:

- The **base** is the primary (widest) frame. Base edits are plain
  unprefixed classes / inline styles and cascade down to every narrower
  breakpoint unless overridden there.
- Edits made while a **narrower breakpoint is active** persist as
  width-scoped overrides that apply from just below the next-wider frame
  down to zero. Narrower breakpoints layer their own overrides on top.

The bound for an override is `next-wider frame width - 1` (e.g. breakpoints
390/810 with a 1280 primary: editing 810 scopes to `≤ 1279px`, editing 390
scopes to `≤ 809px`). `breakpointUpperBoundPx` in
`shared/responsive-classes.ts` is the canonical implementation.

## Managing breakpoints

A newly generated design's frame set comes from `generate-design`'s `devices`
param (`("mobile"|"tablet"|"desktop")[]`, default `["desktop","mobile"]`). The
cascade is **desktop-base**: the widest requested device is the primary/base
frame and each narrower device is a breakpoint frame. The default injected set
is therefore a Desktop base plus a single Mobile (390) breakpoint frame — the
narrower frame(s) only, never a frame at the primary desktop width and never an
auto-added tablet.

- `add-breakpoint` — adds a device-width frame to `designs.data.breakpointSet`
  (Framer defaults: Desktop 1200 / Tablet 810 / Phone 390, or custom 320-3840).
  Duplicate widths are ignored.
- `remove-breakpoint` — removes one by id (overrides already written stay in
  the document until removed).
- `set-active-breakpoint` — persists the active edit scope to application
  state (`design-active-breakpoint:<designId>`); the UI mirrors it in the
  `design-selection` state (`activeBreakpointId`). Check the active
  breakpoint via `view-screen` before making responsive-only edits. Its
  `editScope` is `cascade-smaller` by default (edits at this breakpoint also
  apply to every narrower one); pass `only` when the user explicitly wants a
  bounded, breakpoint-only override.

The UI's breakpoint bar (chips above the focused screen) and the overview's
side-by-side linked frames drive the same state — a chip click changes the
iframe viewport width AND calls `set-active-breakpoint`.

## Editing responsively (agent parity)

Use `apply-visual-edit` with `activeFrameWidthPx` set to the ACTIVE
breakpoint frame width. This scopes BOTH `class` and `style` intents
uniformly through one class-vs-media decision:

- Values that are Tailwind utilities (`text-lg`, `p-4`) become width-scoped
  classes: `max-[809px]:text-lg` (arbitrary max-width variants the Tailwind
  CDN JIT compiles to `@media (max-width: 809px)`).
- Raw CSS values (`137px`, `rgb(...)`, `calc(...)`) persist into the managed
  `<style data-agent-native-breakpoints>` block as
  `@media (max-width: <bound>px)` rules targeting the element's
  `data-agent-native-node-id`. The block is deterministic (wider buckets
  first so narrower ranges win by source order) and readable/editable in the
  Code panel.

Other targeting options:

- `maxWidthPx` — explicit desktop-down bound, overrides derivation.
- `intent.kind: "breakpoint-style"` — direct managed-media write/remove:
  `{ target, maxWidthPx, property, value, operation: "set" | "remove" }`.
- `activeBreakpoint: "md"` etc. — LEGACY min-width prefix scoping for class
  edits only (mobile-first `md:text-lg`). Still supported for documents
  authored mobile-first; prefer `activeFrameWidthPx` for breakpoint-bar
  parity.

When the design has no breakpoint set, `activeFrameWidthPx` falls back to
the legacy min-width prefix behaviour for class edits. When the active frame
IS the widest context, edits are base writes (correct — the widest frame is
the base).

## Resolving and inspecting overrides

- `effectiveUtilityAtWidth(className, stem, widthPx)` — which utility
  renders at a width (narrowest applicable max-width scope wins, then
  min-width prefixes, then base).
- `getBreakpointOverrideState({ className, html, nodeId, property,
  breakpointWidths, baseWidthPx, activeWidthPx })` from
  `shared/breakpoint-media.ts` — aggregates class + media overrides for the
  inspector's overridden-at-this-breakpoint indicators.
- To RESET an override: remove the scoped class
  (`responsive-class` remove with `maxWidthPx` + stem) or the media rule
  (`breakpoint-style` with `operation: "remove"`); the base value cascades
  back down.

## Cautions

- Managed media rules anchor on `data-agent-native-node-id`. Inline (SQL)
  designs keep these ids; localhost write-back strips them — for local-file
  sources prefer scoped classes.
- Never rewrite the managed block wholesale by hand; use the edit intents so
  same-property writes replace instead of accumulate. The parser tolerates
  Code-panel edits but unknown selectors are ignored.
- Adding a breakpoint between two existing widths changes the bound for NEW
  overrides only; previously written overrides keep their original bounds.

Versions

The database has no other skills named responsive-breakpoints.

Database snapshot: 13.11.2026 · package version 5e217f31dbf8 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100responsive-design-advisor
    Design responsive layouts with breakpoints, mobile-first approach, and flexible grids. Use when creating responsive designs, implementing breakpoints, or optimizing for multiple screen sizes.
  • 100audit-responsive
    Audit and fix layouts at every breakpoint; desktop is not a wide phone. Use when "responsive audit", desktop looks stretched, there is no max-width, or 1440 looks like a phone. Touch-first build → design-mobile-first.
  • 90adapt
    Adapt designs to work across different screen sizes, devices, contexts, or platforms. Implements breakpoints, fluid layouts, and touch targets. Use when the user mentions responsive design, mobile layouts, breakpoints, viewport adaptation, or cross-device compatibility.
  • 90adapt
    Adapt designs to work across different screen sizes, devices, contexts, or platforms. Implements breakpoints, fluid layouts, and touch targets. Use when the user mentions responsive design, mobile layouts, breakpoints, viewport adaptation, or cross-device compatibility.
  • 100fai-design-responsive
    Design responsive layouts for AI tools and dashboards — breakpoints, fluid grids, container queries, and mobile-first patterns. Use this skill when a UI breaks on mobile, building a dashboard, or supporting multiple screen sizes — even if the user only says "make it work on phones".
  • 100verify-responsive
    The default way to check a responsive UI — render the real page at real viewport widths in fixed-width iframes, then drive and assert it from the parent. Use whenever you need to see or verify a layout at a given width: a mobile or tablet breakpoint, or small-screen-only…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.