Designers

Reads alt text on a page. Pass a public `url` or `html`. Counts every img element (not a sample) and states how many it read and how many it skipped as aria-hidden or presentational. Flags missing alt, file names and camera names (IMG_1234, Name_With_Underscores.jpg), alt equal to the file stem, placeholder words, "image of" openers, fallback patterns such as "Title, picture", duplicate alt text across different images, alts over 150 characters, and empty alt inside a link that has no other text. Also checks og:image:alt and twitter:image:alt (missing, empty, or poor). Tells you if the page was cut off. Reads delivered markup only: script-added images, CSS backgrounds and inline SVG are not seen, and it cannot judge whether a clean description is accurate.

Analyse an open card sort (method after Donna Spencer, Card Sorting). Pass `participants`: an array with one entry per person, each a map of group name to a list of cards (or {id, groups: {...}}). Accepts 3 to 60 participants and 5 to 100 distinct cards. Returns a similarity matrix (percent of participants who grouped each pair), agreement per card pair, suggested categories from average-linkage hierarchical clustering cut at `threshold` percent agreement (default 50), cards with low agreement, and a table of the group labels people used with how many used each. Card names match case-insensitively; labels match on letters and digits only, so synonyms stay separate. Fewer than about 15 participants triggers a caution. It does not explain why people grouped cards, so follow up with interviews.

Approximate between sRGB and CMYK. Pass `value` as hex (#1a2b3c), rgb(26,43,60) or cmyk(60,40,40,100). Returns the other model by a plain formula (K = 1 - max(R,G,B); C = (1 - R - K) / (1 - K); and R = 255 x (1 - C)(1 - K) back), total ink, and gamut cautions. This ships NO Pantone or other licensed colour data: if you pass a spot name such as 'PANTONE 485 C', it tells you to look the value up in your licensed swatch book or Adobe's libraries and paste the RGB or CMYK here. APPROXIMATION ONLY: real conversion needs an ICC profile and the paper; the printed colour will differ. Proof it.

Audit screen copy, HTML or a public URL for deceptive-design (dark pattern) signals: confirmshaming, forced continuity and hard-to-cancel flows, pre-selected options, false urgency and fake scarcity, misdirection by visual weight, hidden costs, trick questions and double negatives, nagging, forced action or registration, disguised ads, obstruction, and social proof without a source. Give text (one string per line, optional prefixes like button:, link:, checkbox:), and/or html, and/or url. Markup signals include checked inputs, a prominent accept button beside a quiet decline link, countdown timers and cancel flows longer than sign-up flows. Each finding has severity, the evidence string and a fix, and echoes frameworks in general terms (FTC negative option guidance, EU Digital Services Act and Consumer Rights Directive, CPRA). Signals for review, not a legal finding.

Accessibility audit of marketing or transactional email HTML. Pass the full source as `html`. Checks layout tables missing role=presentation, missing lang and title, images without alt or with decorative alt mistakes, image-only emails and likely text in images, vague link text such as "click here", font sizes under 14px, low-contrast inline colour pairs, missing preheader, fixed width over 600px, heading structure, color-scheme declaration, estimated tap-target height of table-built buttons, and reading-order risks in multi-column tables. Email clients differ and this reads markup only: it does not render the email, resolve <style> classes for colour, or confirm a plain-text alternative. Each finding names the WCAG criterion and a fix.

Audit a form's markup and its error messages, with extra care for sign-up and payment forms. Pass `html` or a public `url`, and optionally `errors` (error message strings, one per line). Checks programmatic labels and placeholder-only labels (WCAG 1.3.1, 3.3.2, 4.1.2), autocomplete tokens on personal data fields (1.3.5), wrong input types and inputmode for phone, email, card and one-time codes, password fields that block paste or lack a show-password option, required fields not marked in text or in aria, fieldset and legend on radio and checkbox groups, error wiring (aria-describedby, aria-invalid, live regions, error summary), disabled submit buttons, CAPTCHA without an alternative (3.3.8), and redundant entry (3.3.7). Each error string is checked for saying what happened, saying how to fix it, blame, jargon, the word invalid, and generic wording. Findings carry criterion, severity and fix. Reads static markup only; colour-only errors and script-built fields need a browser check.

Audits a set of inline SVG icons. Pass `icons` as markup containing one <svg> (or <symbol>) per icon. Reports mixed viewBox sizes, missing viewBox, non-square boxes, width and height ratios that disagree with the viewBox, mixed outline and solid styles, stroke widths and linecap or linejoin that vary, hard-coded colours instead of currentColor, icons neither aria-hidden nor named (WCAG 1.1.1), icons with both, ids repeated across icons, path points outside the viewBox, and icons that fill the artboard very differently from the median. Path extents use command endpoints only and only <path> data. Stroke and grid expectations are conventions. Static; nothing is rendered.

Audit pasted CSS for motion problems. Pass `css` (stylesheet text with @keyframes, animation and transition rules). Optional flash data you measured or know from the design: `flashes_per_second`, `flash_area_percent` (share of the screen that flashes). Flags: animation or transition of layout properties (width, height, top, left, margin, padding, font-size and similar, which force layout), paint-heavy properties, `transition: all`, animations or transitions with no matching prefers-reduced-motion rule, infinite animations with no animation-play-state or pause control in the CSS (WCAG 2.2.2), long durations, and flashing risk against WCAG 2.3.1 (more than three flashes in any one second, unless the flashing area is small). Flash rate from CSS is estimated from the animation duration and cannot see luminance change. Static analysis only.

Audit one page's static HTML for accessibility problems and name the WCAG 2.2 criterion for each: missing lang or title, images without alt, unlabelled form fields, vague or empty links and buttons, heading jumps, no main landmark, zoom-blocking viewport, autoplay with sound, tabindex above zero, duplicate ids, click handlers on non-interactive elements, tiny inline targets. It reads markup only and cannot test contrast, focus order or script-built widgets.

Pro. Crawl up to 15 same-origin pages from a start URL, audit each one's static HTML for WCAG 2.2 problems, and report issues by how many pages they affect so that shared-template problems come first. Returns a markdown report.

Audit spacing in a stylesheet. Pass `css` (free) or a public `url` (Pro). Reads margin, padding and gap properties (shorthands split into their parts; rem and em converted with the root size the CSS sets; auto and 0 skipped), then reports the detected base unit (8 if 85% of uses fit, else 4, else none with the best fit), the number of distinct values against a budget of 12, off-grid values with counts, gaps between steps, values used once, the split between margin, padding and gap, and a proposed scale with an old-to-new table. Percent, vw, calc() and clamp() values are counted as fluid and left out of the scale.

Audit the scales behind a set of design values. Pass `css` (free), a public `url` (Pro), or `values` (JSON with any of colors, fontSizes, spacing, radii; each a list of strings, or {value, count} objects). Reports: colours within deltaE 2 of a more used colour (with the one to keep), font sizes, spacing and radii within 1px of each other, values that sit off the detected 4px or 8px grid, gaps between steps, values used exactly once, and a proposed consolidated scale with a table mapping every changed old value to its new value. Mappings snap to the nearest standard step and should be checked on screen before applying.

Audit a stylesheet's typography. Pass `css` (free) or a public `url` (Pro). Reads font-size, the font shorthand and line-height, converts rem and em with the root size the CSS sets, and reports: every size with its use count, the modular ratio that best explains the sizes (major second to octave, with the share of sizes it covers) or that none fits, sizes that fall off that ratio, pairs less than 2px or 10% apart, the number of distinct sizes against a budget of 8, the body size (under 16px is flagged, under 14px is high), text under 12px, and line heights that are tight, loose or wrong for the size. Fluid sizes written with clamp() or vw are counted but not placed on the scale.

Suggest a brand architecture model per product. Give `products` as lines 'Name | audience=same | category=overlap | risk=low | standalone=no | acquired=no' (or objects with those keys) and optionally `company`. audience and category take same, overlap or different relative to the parent; risk is the chance a problem with one damages the other (low, medium, high); standalone says whether it needs an identity that can live alone; acquired says whether you bought it. Returns branded house, house of brands or endorsed brand for each with scores, the reasons, which facts were missing and treated as neutral, an example naming pattern, and an overall tally with a note when the portfolio is mixed. Scoring is our own simple rule, a starting point for discussion.

Check brand voice consistency across samples. Give `samples` (a list, or text with samples separated by a line of ---, or by blank lines; 2 to 40) and optionally `rules` (plain lines or JSON: banned words, 'use X not Y', capitalisation of names, punctuation bans, max sentence length, required terms) and `bannedWords`. Returns per-sample sentence length (mean, spread, longest), contractions, you/we use, a 0 to 100 formality score from transparent measures, drift flags where a sample is 15+ formality points or 35% in sentence length from the set, rule violations by sample, and required terms that never appear. Heuristic, English only; it compares samples with each other, not with a standard.

Build a column grid from page or container width. Pass `width`, and optionally `columns` (default 12), `gutter` (default 24), `margin` (default 24). Returns the column width, the x position of every column, the width of every span from 1 to N columns, CSS grid code (fixed pixel and fluid fr versions), and the Figma layout grid settings. Flags fractional column widths and suggests the nearest widths that give whole pixels. For a modular grid, also pass `rows` and `height`; optionally `rowGutter` (defaults to the gutter) and `baseline` (line height in px). The modular result gives module size, row positions, CSS, and whether module height plus row gutter lands on whole baseline lines, with the module height that would fix it (a convention). Rejects zero, negative, NaN and layouts where the columns do not fit. Sources: Müller-Brockmann, Grid Systems in Graphic Design; Samara, Making and Breaking the Grid; Marcotte, Responsive Web Design. Pure arithmetic, nothing stored.

Pro. Build a scored, exportable markdown report from heuristic evaluation findings you have written. Each finding has heuristic (1 to 10), severity (0 to 4), location, issue, effect, fix and optional effort (S, M, L) and evaluator. Merges duplicates across evaluators, computes a health score, and sorts a fix-first table.

Generate spacing tokens from a base unit. Pass `base` (px, default 8) and one of: nothing (linear 4/8-point ladder: half step, 1x, 1.5x, 2x, 3x, 4x, 5x, 6x, 8x ...), `ratio` (modular: base times ratio to the power n, starting at the base), or `steps` (your own list of px values). `count` sets the token count (default 10, max 18 for linear and 24 for modular). Each token returns px, rem at 16px, a usage line (hairline gap, inside a component, component padding, between siblings, between groups, between sections), and a flag when the value is not a whole multiple of the base or is a fractional pixel. Also returns CSS custom properties in rem and in px, with an optional `prefix` (default space). Sources: Samara, Making and Breaking the Grid (consistent units); Graver and Jura, Best Practices for Graphic Designers (modular scales). The 4 or 8 point unit itself is a convention. Pure arithmetic, nothing stored.

Check a list of interface labels for consistency. Give `labels` (one per line; repeat a label once per place it appears so counts are real) and optionally `groups` (your own synonym sets, one per line, comma separated). Groups labels that name the same action from a built-in list of about 17 actions (sign in/out/up, delete, cancel, save, edit, add, next, back, buy, view, download, search, send, share, confirm), suggests the most-used label as the standard, and flags mixed Title Case and sentence case, all capitals, inconsistent end punctuation and generic labels. Some groups depend on context; merge only where the action is truly the same.

Estimate movement time with Fitts's law (Shannon form: a + b * log2(distance / width + 1)) and decision time with the Hick-Hyman law (a + b * log2(choices + 1)). Pass `distance` and `width` for one target, `choices` for a choice set, and/or `layouts`: 2 or 3 layouts, each {name, targets: [{label, distance, width}], choices} to compare total time. Constants are configurable with `fitts_a`, `fitts_b`, `hick_a`, `hick_b` (milliseconds; defaults a=100, b=150 for pointing and a=200, b=150 for choice, typical illustrative values). These are models: the defaults are not measured on your users, so use results to compare layouts, not to predict seconds. Sources: Fitts 1954, MacKenzie's Shannon formulation, Hick 1952, Hyman 1953, as context in Cooper's About Face and Norman. Constants and laws are stated from general knowledge, not verified against the design library.

Calculate resolution for print. Pass print `width` and `height` with `unit` (mm, cm, in), optional `viewing_distance` with `distance_unit` (cm, in, m) and optionally `pixels_w`, `pixels_h` of the image you have. Formulas: pixels = size in inches x ppi; the ppi a viewer can resolve at distance d is 1 / (2 d tan(0.5 arcminute)) which is about 3438 / d(inches), assuming normal 20/20 vision resolves 1 arcminute; effective ppi = pixels / size in inches. Returns pixels needed at the acuity-suggested ppi (capped at 300) and at 300 ppi, and, if you give pixel dimensions, the effective ppi and a verdict. 300 ppi is the usual figure for work held in the hand; large format is viewed from farther away and can go lower. The vendor's stated minimum wins. 'DPI' here means image pixels per inch.

Work out print document sizes. Pass `trim_width` and `trim_height` with `unit` (mm, cm, in, pt), optional `bleed` (default 3 mm; the common European figure, US printers often ask 0.125 in = 3.18 mm), `safe` margin inside trim (default 5 mm), and for books `pages` (counted as printed pages, 2 per leaf), `caliper` (thickness of ONE sheet of the paper) with `caliper_unit` (microns, mm, mil = thousandth of an inch, which paper trade calls points, or in), `spine_extra_mm` for glue allowance, and `binding` (perfect, saddle, none). Formulas: size with bleed = trim + 2 x bleed; safe area = trim - 2 x safe; spine = (pages / 2) x caliper + extra; cover spread width = 2 x trim width + spine + 2 x bleed. Spine is an estimate: the printer's own template and paper stock win, and hardcover case binding adds board thickness not computed here.

Work out proportions. Pass `ratio` (golden, root2 or a-series, root3, any a:b such as 3:2 or 16:9, or a decimal such as 1.414; default golden) and `width` or `height`. Optionally `orientation` (landscape by default, or portrait) and `container` (length to split; defaults to the long side). Returns the missing side, the split of the container into a major and minor part at that ratio (with CSS fr and px forms), a table of heights at the same width for ten common ratios, and, when you give both width and height as a source image, centred crop sizes and offsets for the target ratio and common alternatives with the share of area kept. Root-2 is the ISO A-series ratio, where folding a sheet in half keeps its shape. Sources: Graphic Design Solutions (golden section); Samara, Making and Breaking the Grid; Müller-Brockmann, Grid Systems in Graphic Design. That any one ratio is more beautiful is a convention, not a finding. Pure arithmetic, nothing stored.

Pick a chart type from the question being asked and the shape of the data. Pass `question` (compare, trend, distribution, part-to-whole, relationship, ranking, geography) and any of: `categories` (number of groups or items), `points` (observations or time steps), `series` (number of series), `thirdVariable` (relationship questions: a third measure to encode), `hierarchy` (parts nest inside parts), `overTime` (the question is across time), `audience` (general or analyst). Returns `ranked` chart types, each with a reason tied to your numbers, `avoid` (chart types that mislead for this question) and `notes`. Draws on the practice described by Stephen Few (Show Me the Numbers) and Alberto Cairo (The Functional Art); the rankings are our own judgement, not a formula. Pure computation.

Check a set of chart series colours. Pass `colors` (list or comma-separated string of hex, rgb(), hsl() or CSS names, up to 24), `background` (default #ffffff) and `chartType` (bar, line, area, pie, scatter, map and so on). Returns: contrast of each colour against the background with the 3:1 minimum for graphics (WCAG 2.x non-text contrast) and the nearest passing shade; pairwise colour distance (CIE76 delta E) under typical vision, protanopia, deuteranopia, tritanopia (Machado et al. 2009 model) and greyscale, flagging pairs below 10 for filled marks or 15 for thin marks (working conventions, not standards); duplicate colours; a count warning past seven categorical hues; and a direct-labelling recommendation when there are more than four series. Also lists which colours of the Wong palette (Bang Wong, Points of view: Color blindness, Nature Methods, 2011) stay at 3:1 on your background. Pure computation.

Lint a chart specification for graphical integrity, in the tradition of Edward Tufte (The Visual Display of Quantitative Information) and Alberto Cairo (How Charts Lie). Pass `spec` as a JSON object or JSON string with: type (bar, column, line, area, pie, donut, scatter, bubble), title, source, units, labels (categories), series (list of {name, values, axis?}), axis {min, max, label}, axis2 {min, max} or dualAxis, threeD, stacked, sizeEncoding (area, radius, diameter, width, volume), decoration (list or object naming gradient, shadow, pattern, texture, heavyGridlines, border, backgroundImage, pictograph, ornament), valuesArePercent. Checks: clipped data, non-zero bar or area baselines with the lie factor (size of the effect shown in the graphic divided by the size of the effect in the data) computed from your first series, zoomed line axes, size encodings that scale by radius or volume (with the drawn ratio worked out), 3D, decoration that lowers the data-ink ratio, pies with more than about five slices or negative values, stacked or multi-line overload, dual axes, and a missing title, source or units. Each finding has an id, severity (error, warn, info), plain explanation and the numbers behind it. Pure computation: nothing is stored or logged.

Static review of line-breaking and typography settings where CJK or Thai text appears. Pass `source` as HTML with styles, or CSS plus sample text. Detects Han, kana, Hangul and Thai in the content, then flags word-break: break-all and keep-all used on the wrong script, missing lang (which selects glyph variants and break rules), <br> inside CJK paragraphs, spaces between CJK characters, widths set in ch, line-height under 1.5, letter-spacing, italics, nowrap, and lines starting with closing punctuation. Mentions line-break strict and loose and phrase-aware breaking where relevant. Reads the pasted source only; nothing is rendered or run, stored or logged. Wrapping happens in the browser, so check in a real one with a native reader.

Check colours for print. Pass `colors` as lines: hex (#1a2b3c), rgb(26,43,60), cmyk(60,40,40,100) or C=60 M=40 Y=40 K=100, or a spot name (Pantone, HKS, RAL and so on). Optionally `stock` (coated, uncoated, newsprint) for the total area coverage (TAC, sum of the four ink percentages) limit, and `smallest_text_pt` for the smallest black text. Reports the mode of each line, naive CMYK for RGB (no colour management), TAC against the limit (conventions: about 300 coated, 260 uncoated, 240 newsprint; the printer's figure wins), rich black versus flat K, 400% registration black, near-pure-RGB colours likely to fall outside the CMYK gamut, spot colours that add a plate, and overprint notes.

Check colour contrast. Give fg and bg, or pairs (a list of {fg, bg, label, sizePx, bold}), or a palette. Returns the WCAG 2.2 ratio with AA and AAA results for the text size, APCA Lc with what it is enough for, the nearest passing colour, and for palettes the colour pairs that become indistinguishable under protanopia, deuteranopia or tritanopia. Accepts hex, rgb(), hsl() and CSS names.

Take a design token file (CSS custom properties like --color-text: #111;, a JSON object of colours, or W3C design tokens) and test every foreground-like token against every background-like token for 4.5:1 text and 3:1 component contrast, with the nearest passing colour, and find colours that merge under colour blindness. Free up to about 30 colours; Pro takes 200. Returns a markdown report.

Compare design tokens from the design tool with what the code uses. Pass `design` (W3C design tokens JSON, Tokens Studio JSON, flat key/value JSON, or CSS variables) and `code` (CSS, SCSS or a Tailwind theme with custom properties or hex values). Both are parsed forgivingly. Returns findings grouped by severity with a count summary: design tokens missing from code, code tokens missing from design, same name with a different value (colour distance in deltaE, px and rem normalised at 16px), different names with identical values (rename candidates), near-duplicate colours inside the code (deltaE under 2), hard-coded values in code that equal a token exactly, and values that are close to but not exactly a token, naming the token. No AI, nothing stored.

Check an email for accessibility basics. Pass `html`. Reports: missing lang and title, layout tables without role="presentation", images with no alt or throwaway alt (image, photo, a file name), very long alt text, links with vague wording (click here, read more, here), links with underline removed and no other cue, heading structure (none, or skipped levels), colour contrast of text and background set on the same element (WCAG 1.4.3, 4.5:1), small text, all-caps blocks, and text locked inside images. Static checks only; it does not replace a screen reader pass. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.

Check how an email will fare in dark mode. Pass `html`. Reports whether it declares color-scheme (meta and CSS), has a prefers-color-scheme: dark block, uses Outlook.com's [data-ogsc]/[data-ogsb] hooks, hard-codes white or near-white backgrounds, pairs colours that already have low contrast, uses mid-tone text colours that tend to fail after forced inversion, relies on background images, and has images likely to need a transparent or outlined version. Clients behave in three ways (leave as is, partly invert, fully invert); our notes describe them, and they drift. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.

Check a preheader (the preview text after the subject in the inbox). Pass `html` (the email; the first hidden block at the top of the body is read) or `preheader` text directly, and optionally `subject`. Checks: missing preheader, length (under about 40 characters lets the client pull in body text; over about 110 to 140 gets cut, both estimates and client dependent), repeating the subject, filler such as 'View in browser', padding characters to push body text out, and whether the hiding method is sound. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.

Check an email subject line. Pass `subject`. Reports length in characters (phones show roughly the first 30 to 45; desktop 55 to 70, estimates), word count, spam-trigger words from a short list of about 35 phrases (filters weigh many signals, so a hit is a nudge, not a verdict), ALL CAPS, repeated punctuation, dollar signs and percent claims, emoji count, fake Re:/Fwd:, leading or trailing spaces, and personalisation placeholders (found, missing fallback, unbalanced braces, empty tags, leftover undefined/null/NaN).

Maps text to scripts using a built-in Unicode block table (Latin including Vietnamese, Greek, Cyrillic, Hebrew, Arabic, Indic scripts, Thai, Lao, Khmer, Myanmar, Georgian, Armenian, Ethiopic, Hangul, kana, Han, symbols, emoji). Pass `text` and optionally `fonts` as a comma-separated family list. Returns blocks present with counts and sample characters, the scripts needed, which listed families are known to cover each (from a small table of common fonts, with Noto per-script families recognised), gaps with a suggested Noto family, and notes on Han unification and RTL. Font coverage is from general knowledge of common fonts and varies by version and OS, so confirm in the font file; unknown fonts are reported as unknown. Nothing is rendered.

Check a form's markup against the style rules in Luke Wroblewski's Web Form Design. Pass a public `url` (fetched safely, public hosts only) or pasted `html`. Reports findings with severity (high, medium, low, info) and a fix for label association and placement, placeholder used as a label, required and optional marking, number of fields, input types and autocomplete tokens, inline validation hooks (native constraints, aria-describedby, aria-invalid), vague or risky buttons (Submit, Reset, disabled submit), and ungrouped radio, checkbox and payment fields. Where a check is a common convention and not his stated rule, the finding says so. Reads static markup only: it cannot see CSS, so top versus left label alignment is not confirmed, and script-built fields are invisible. For WCAG-referenced form findings and error message linting, use audit_form.

Checks a design handoff list for gaps. Pass `spec` as JSON (an array of {name, states, sizes, tokens, behaviours, notes, redlines}) or as lines such as `Button | states: default, hover | sizes: 40px | tokens: color.brand.500 | behaviour: truncates`. The component type is inferred from the name (button, input, checkbox, toggle, select, link, tab, modal, tooltip, list or table, card, avatar, navigation) and compared with the states usually needed for that type, plus sizes (including WCAG 2.5.8 target size), token categories (colour, spacing, type, radius), and behaviours (keyboard, long text, resize, empty, loading, error, focus, focus trap, motion timing). Lists redlines worth requesting. The expected sets are conventions. It sees only what you paste, not the design file.

Static scan against WCAG 2.5.1 Pointer Gestures, 2.5.2 Pointer Cancellation, 2.5.3 Label in Name, 2.5.4 Motion Actuation, 2.5.7 Dragging Movements, 2.5.8 Target Size (Minimum), 2.1.1 Keyboard and 1.4.13 Content on Hover or Focus. Pass `source` as HTML, CSS and any script you want covered. It finds :hover reveals with no focus twin, mouseover without focus, title-only names, draggable items and drag libraries, touchmove, swipe and pinch handlers, mousedown or touchstart actions, devicemotion, aria-label that does not contain the visible text, controls declared under 24 CSS px, and click handlers on non-interactive elements. Reads the pasted source only; nothing is rendered or run, stored or logged. Listeners added by bundled libraries are invisible unless named.

Checks a shortcut map. Pass `shortcuts`, one per line in the form `Cmd+K: Open search` (Mod, Cmd, Ctrl, Alt, Option, Shift and symbols like the command key are understood), and optionally `platform`: any (default), mac or windows. Flags duplicates within your list, collisions with common browser, text-editing and OS shortcuts, Ctrl+Alt combinations that equal AltGr on Windows or the VoiceOver modifier on Mac, screen reader keys, and single-character shortcuts under WCAG 2.1.4 Character Key Shortcuts (turn off, remap, or active only on focus). The built-in table is a convention-level summary of defaults, not exhaustive. No rendering, nothing stored.

Static motion audit against WCAG 2.2 (2.2.2 Pause, Stop, Hide; 2.3.1 Three Flashes; 2.3.3 Animation from Interactions). Pass `html` and/or `css`, or a public `url` (the page and up to 4 same-site stylesheets are fetched). Flags autoplay video and audio, marquee and blink, infinite animations with no pause control, animation patterns that could flash (it cannot measure flash rate), parallax and scroll-linked motion, large translate or scale transitions, smooth scrolling, and durations over 400ms. Reports whether prefers-reduced-motion is honoured (counts animations and transitions against reduced-motion rules) and returns a ready-to-paste reduced-motion CSS block. Each finding names its criterion, severity and fix. Reads source only; does not render the page or run script.

Reviews the name inputs in form markup and nearby script. Pass `markup` (HTML, optionally with script). Detects first, last, full, middle and title or gender fields from name, id, placeholder and label, then flags a first and last pair with no single-name option, maxlength under 50, minlength over 1, patterns and regexes that allow only A to Z, required middle name or title, split-on-space logic, and missing autocomplete tokens (WCAG 1.3.5). Guidance follows W3C internationalisation material on personal names, applied as convention. Server rules and database columns are not visible. Reads the pasted source only; nothing is rendered or run, stored or logged.

Audits names. Pass `names`, one per line; use slashes for paths or two-space indentation for nesting. Classifies each segment as kebab, snake, camel, Pascal, upper snake, title words or lower words and reports the dominant style and strays, then flags default tool names (Frame 12, Group 4, Rectangle), draft or version markers (final, copy, new, v2), names that repeat or differ only by case or separator, stray whitespace, emoji and file-unsafe characters, names over 40 characters, depth beyond 5 levels, mixed path separators and inconsistent state casing. It flags inconsistency, not which style is right. Works on the pasted names only.

Find layout slips that read as mistakes. Pass `boxes` (array or JSON string of {x, y, w, h, label}, 2 to 400 boxes) or `html` plus optional `css`. For markup, geometry comes from data-x, data-y, data-w, data-h attributes or from left, top, width and height in px (inline style, or simple .class, #id and tag rules in `css`); elements without all four are skipped and counted. Nothing is rendered, so this reads declared numbers only. Reports (1) near-misses: left, right, top, bottom or centre lines of two boxes that differ by more than 0.01px and no more than `tolerance` (default 6px), with both values and the difference; (2) inconsistent gaps between three or more siblings that share a row or column, listing every gap and the most common one; (3) orphans, boxes that line up with nothing and sit more than twice the median nearest-neighbour distance away. Sources: Müller-Brockmann, Grid Systems in Graphic Design (alignment to a shared structure); Lupton, Thinking with Type (alignment and grouping); Wroblewski, Web Form Design (labels close to their fields). The tolerance and orphan thresholds are conventions. Pure arithmetic, nothing stored.

Static check for WCAG 1.3.2 Meaningful Sequence and 2.4.3 Focus Order. Pass `source` as HTML with style blocks and inline styles, or as bare CSS. Flags CSS order, row-reverse and column-reverse, grid-auto-flow: dense, explicit grid placement, absolute and fixed positioning, right floats, positive tabindex, a footer before main in the DOM and skipped heading levels. Returns the DOM sequence of landmarks and headings so you can compare it with the visual order. Reads the pasted source only; nothing is rendered or run, stored or logged. It does not compute layout, so media-query rules are flattened and selectors are not matched to elements.

Static reflow audit against WCAG 1.4.4 Resize Text, 1.4.10 Reflow, 1.4.12 Text Spacing, 1.3.4 Orientation and 1.4.13 Content on Hover or Focus. Pass `html` and/or `css`, or a public `url` (the page and up to 4 same-site stylesheets are fetched). Flags viewport meta that blocks zoom, fixed pixel widths and min-widths over 320px, overflow hidden with fixed heights, px base font sizes, vw font sizes without clamp, !important on line-height, letter-spacing or word-spacing, orientation locks, nowrap text, tables without a scroll wrapper, hover-only reveals, and pages with no width media queries. Each finding names the criterion and gives the fix. Reads source only: it does not lay the page out or run script, so confirm at 320px width and 400 percent zoom.

Static review for right-to-left languages. Pass `source` as HTML with styles, or CSS. Lists margin, padding, border, left, right, float, clear, text-align, border-radius corner and translateX declarations with the logical replacement (margin-inline-start, inset-inline-end, text-align: start and so on), flags letter-spacing and italic on Arabic, justified Arabic, bidi overrides and embedded control characters, missing html lang and dir, free-text inputs without dir="auto", phone-like strings that need <bdi>, and directional icons by name (arrows, chevrons, back, next, reply, send) that usually mirror versus ones that do not (play, search, check, logos). Icon advice is by name and follows common guidance, so treat it as convention. Reads the pasted source only; nothing is rendered or run, stored or logged.

Check interaction states in a stylesheet. Pass `css` (free) or a public `url` (Pro). Finds links, buttons, inputs, selects, summaries and classes that look interactive (btn, link, tab, toggle, switch, checkbox, chip, dropdown, form-control and others) or that already have a hover or focus rule, then lists for each which of :hover, :focus-visible (or :focus), :active, :disabled and aria or checked states have styles. A missing focus-visible style is high severity; a global :focus-visible rule counts for everything. Flags every rule that sets outline to none or 0 where no :focus or :focus-visible rule for the same element draws a ring, shadow or border instead (the :focus:not(:focus-visible) pattern is allowed).

Static bloat review for one SVG. Pass `svg`. Flags XML prolog and DOCTYPE, comments, editor markers (Inkscape, Sodipodi, Sketch, Illustrator, Figma, default Layer ids), generator notes used as title, path numbers with more than 3 decimals (with the characters that rounding to 2 or 3 would remove), hidden elements, empty and attribute-less wrapper groups, unreferenced ids, unused clip paths, masks, gradients and filters, attributes at default values, embedded base64 bitmaps, live text, matrix transforms, a missing viewBox, and script or external references. This tool does not rewrite or optimise the SVG and does not claim output; the byte estimate counts characters that the listed items occupy. Use SVGO or similar and compare the render.

Check target sizes and spacing against WCAG 2.2 SC 2.5.8 (24 by 24 CSS px, or a smaller target with enough spacing), the 44px guidance for iOS and the web, and 48dp for Android. Pass targets as a list of {name, width, height, gap, inline} or text lines like 'Save button 40x32 gap=8'. Returns pass or fail per guideline with advice.

Static audit of how much a screen asks of a person. Pass `content` as HTML (best) or plain text. Reports interactive controls per screen, words, sentence length, an English reading-ease estimate, long paragraphs, missing headings, and form length, then checks WCAG 2.2 criteria that matter for cognition: 2.2.1 Timing Adjustable (meta refresh, countdown and session language), 3.3.8 Accessible Authentication Minimum (paste or autofill blocked, CAPTCHA or puzzle language), 3.3.7 Redundant Entry (confirm fields), 3.3.2 Labels or Instructions (placeholder-only fields, unexplained required fields), 1.3.5 Identify Input Purpose (missing autocomplete tokens) and 3.2.2 On Input. Count and length thresholds are conventions and are labelled so. Reads the pasted source only; nothing is rendered or run, stored or logged.

Check status or state colours for colour-vision problems. Pass `states` as lines or comma-separated entries such as `error: #d32f2f, success: #2e7d32`, or an array of {label, color}. Labels like error, success, warning and info (and close variants) get matching icon and text suggestions; any other label gets generic ones. Every pair is compared by CIE76 deltaE under normal vision and simulated protanopia, deuteranopia and tritanopia (Machado et al. 2009, full severity). Under 10 counts as merged and under 20 as weak, both working conventions. Returns each pair's numbers, the worst case, a lightness gap, and a second cue per state with a reminder of WCAG 1.4.1 (Use of Color) and 1.4.11 (non-text contrast for the icon). Simulation covers dichromacy only; milder anomalous trichromacy falls between.

Check a colour palette against a brief. Give `palette` (hex, rgb() or hsl(), optionally named, up to 16) and optionally `brief` (words such as calm, energetic, premium, playful, trustworthy, natural, minimal, warm, cool). Returns measured properties, a verdict per brief word (supported, contradicted or untestable) with the measurement behind it, palette issues (too many colours, no neutral, near-duplicates, pairs that look alike under colour-vision deficiency, no 4.5:1 text pair), and each colour's contrast on white and black. Mood associations are common conventions and vary by culture.

Read a palette's balance. Pass `colors` (two to sixty) as hex, rgb(), hsl() or CSS names, optionally each followed by its area share, such as `#1b3a5c 55%, #f2efe6 30%, #e4572e 10%`, or an array of strings or {color, share}. Returns warm, cool, neutral and in-between share, a chroma-weighted warm/cool index, chroma spread, lightness range and darkest-to-lightest contrast, and the dominant, accent and neutral colours. With shares for every colour it also reports whether the split sits near 60-30-10 (read as 50-70, 20-40 and 5-20, our own tolerance); without shares it says the split cannot be read. Temperature bands are OKLCH hue conventions (warm 350 to 115, cool 180 to 285, neutral chroma under 0.03). Sources: Hughes, Graphic Design: Learn It, Do It; Wroblewski, Site-Seeing.

Compare two versions of a design system. Pass `before` and `after` (each CSS with custom properties, W3C design tokens JSON, or a flat key/value JSON object; free) or `before_url` and `after_url` (Pro). Tokens are matched by name. Reports added, removed, renamed (same value under a new name) and changed tokens, and gives an overall class. Breaking: a token removed or renamed, a type change, a colour that moved by deltaE 25 or more, or a size that changed by half or more. Minor: a new token, a visible colour shift (deltaE 2 to 25) or size change. Patch: a colour change under deltaE 2 or a size nudge of 1px or less. When a side defines no custom properties, the two are compared by the values they use and the class is minor if 15% or more of the values churned, otherwise patch. This is different from check_design_drift, which compares a design file with code at one point in time.

Check inverted-pyramid structure and heading usefulness. Give `text` (markdown-style # headings or 'h2:' prefixes), optionally `keyTerms` (what the reader must see early) and `firstWords` (default 40). Reports where each key term first appears and flags any after the first N words (if no key terms are given, the most repeated words are used and said so); lists the headings alone as the scan test; flags generic headings (Overview, Details), one-word or very long headings, skipped levels, duplicate headings, headings whose words never appear in their text, sections over 160 words, long first paragraphs and sentences, and openings that start with preamble. Position and pattern checks; it cannot judge whether the opening is the right content.

Convert paper sizes. Pass `size` by name (A0 to A10, B0 to B10, C0 to C10, Letter, Legal, Tabloid, Ledger, Executive, Statement, Junior Legal, ANSI C/D/E, Arch A to E, DL, US and EU business cards) or pass custom `width` and `height` with `unit` (mm, cm, in, pt). Returns millimetres, inches, points (1/72 in), pixels at 72, 96 and 300 ppi, aspect ratio, area, the nearest standard sizes with the difference, and the ISO relationships (A series halves the long side; B is the geometric mean of A neighbours; C is the geometric mean of A and B). ISO values are the published whole-millimetre figures.

Extracts real foreground and background colour pairs from CSS instead of guessing roles from token names. Pass a public `url` (the page, its style blocks and up to 12 linked stylesheets are fetched) or paste `css` (and optionally `html` for its style blocks). For every rule that sets `color`, it finds the background set by the same rule, by an ancestor named in the selector, or by body/html, resolves var() custom properties, light-dark() and prefers-color-scheme / [data-theme] / .dark variants, and applies opacity. Returns WCAG ratio, APCA Lc, the threshold (large text 3, otherwise 4.5), file and line for each failing pair, a list of thin margins, a list of pairs whose background is assumed (only the page root or the browser default was available), and text over images or gradients that cannot be computed. Optional `scheme` (both, light, dark) and `viewport` (width in px for min-width/max-width media queries, default 1280). Reads CSS only: no rendering, inline style attributes, script, or text over photographs.

Convert CSS custom properties into W3C design tokens (DTCG) JSON. Pass `css` (a :root block, a whole stylesheet, or a Tailwind v4 @theme block). Each variable is typed from its value and name (colour, dimension in px or rem, duration, number, fontFamily, fontWeight, cubicBezier, shadow), grouped by type (color, spacing, radius, font-size, duration, and so on), and a var(--other) value becomes a {group.name} alias. The original CSS name and any dark value (from prefers-color-scheme: dark or a .dark or data-theme=dark selector) are kept in $extensions so dtcg_to_css can round-trip them. Variables that cannot be typed (calc(), clamp(), percentages, gradients, compound values, references to undefined variables) are listed with the reason instead of being guessed.

Derive a dark counterpart from light-mode tokens. Pass `tokens` as `name: colour` lines (CSS custom properties work), a JSON object of name to colour, or an array of {name, color}. Roles are guessed from the name (surface, raised surface, text, border, accent, on-accent) and then from the colour. Surfaces are rebuilt around OKLCH L 0.19 with raised layers stepped lighter; text is mapped to light values under pure white; borders keep their distance from the surface; accents keep hue, gain lightness and lose about 15 percent chroma. Text and accents are nudged until they reach 4.5:1 on the lightest dark surface. Returns the mapping per token with a note, any pairs that still fail with their ratios, and CSS variables. The lifted-surface approach is a convention, not a standard.

Decide whether data belongs in a table, small multiples, a sparkline or a chart. Pass `rows`, `cols` (numeric columns or series), `purpose` (lookup, compare, pattern, monitor), `precision` (exact or approximate), `space` (inline, tiny, normal, large), `timeSeries` (boolean), `mixedUnits` (boolean), `groups` (how many comparable series or panels could be drawn) and optionally `audience` (general, analyst, executive). Returns `recommendation`, `alternatives`, `reasons` and `cautions`. The logic follows the table-versus-graph reasoning in Stephen Few (Show Me the Numbers) and Edward Tufte's small multiples and sparklines, but the rules and the wording are our own. Pure computation.

Describe an easing and get CSS back. Pass `easing` as a name (ease, ease-out, ease-out-cubic, ease-in-out-quart, ease-out-back and others), as `cubic-bezier(x1,y1,x2,y2)` (x values must sit between 0 and 1), or as `spring` with optional `mass`, `stiffness`, `damping`. Optional `duration_ms` (bezier only; a spring has its own settle time). Returns the CSS timing function, a CSS `linear()` version, 11 sampled points of progress against time, overshoot and settle figures for springs, and notes on feel with a convention for when to use it. The named curve values are widely shared conventions, not a standard beyond the five CSS keywords.

Look for the default AI-generated design look in a live page's markup and CSS: purple-to-blue gradients, gradient text, a default font stack, pill buttons with arrows, uppercase eyebrow labels, emoji headings, glassmorphism, glow blobs, equal card grids, stock marketing phrases and placeholder copy. Returns weighted signals and a 0 to 100 score. Signals, not proof.

Diagnose setup problems. Reports what the server sees about this connection (client, whether a Pro key was received and is active, plan), checks a Figma link for the right shape (frame link with node-id, not a prototype or Community page), and matches a described symptom to fixes for: connected but nothing happens, local versus remote servers, 401 and 403, rate limits, tools or skills not triggering, and Figma selection problems. Does not use up a daily call.

Produce a deterministic brand guideline skeleton. Pass `name` (required), and optionally `audience`, `tone` (words, comma separated or a list) and `constraints` (a list or lines such as "must meet WCAG AA" or "no stock photography"). Returns thirteen sections (purpose, audience, voice, logo, colour, typography, layout and shape, imagery, iconography, motion, accessibility, channels, governance). Each lists what you already decided, the decisions still open and blank lines to fill in. Tone words are matched to a fixed table of design levers (type, colour, shape, motion, voice) and pairs that pull against each other are named; words not in the table are listed as needing a definition. Constraints are sorted into accessibility, legal, existing assets, channels, language, budget and exclusions and shown in the sections they affect. Nothing is generated beyond these templates, so the same input always gives the same output.

Convert W3C design tokens (DTCG) JSON into code. Pass `tokens` (JSON text or object) and optionally `format` (css, tailwind or both; default both) and `prefix` (added to every CSS name). Reads $type and $value with group-level $type inheritance, {alias} references (kept as var() references in CSS, resolved for Tailwind), colour as a string or colour object, dimension and duration as strings or {value, unit}, fontFamily, fontWeight, number, cubicBezier, shadow (one layer or several), border, transition and typography (expanded to one variable per field). Also reads the older value and type keys. Names come from the path (color.brand.500 becomes --color-brand-500) unless the token carries a name from css_to_dtcg. Validation reports missing types, circular or dangling aliases, name collisions and every token that has no CSS form (gradients, strokeStyle objects, unknown types) with the reason.

Checks UI and error strings against WCAG 3.3.1 (Error Identification), 3.3.3 (Error Suggestion), 4.1.3 (status messages that vanish) and plain-language convention. Pass `messages`: a list of strings, or objects `{ text, where, autoDismissMs }` where `where` is inline, toast, tooltip, placeholder and so on. Flags: says what went wrong but not what to do next, states a rule without an action, blames the person, is a code or generic phrase only, contains system jargon, is shouted, runs long, or disappears (toast, tooltip, placeholder, auto-dismiss under 20 seconds). For each message that needs work it returns a fill-in template (problem, then one step) chosen by the kind of error, with the slots named. It does not write the final copy. Judges wording by pattern; it cannot see whether a message is linked to its field or announced.

Assemble error message skeletons. Give `problem` (what happened, required), and optionally `cause`, `fix` (the next step), `where` (field or page), `severity` (blocking, recoverable, warning), `dataSaved` (yes if the user's work is safe), `canRetry` and `contact`. Returns three layouts (inline under a field, banner or toast, full-page with title, body and buttons) built from your wording with square-bracket placeholders where you gave nothing, plus flags: blame words (invalid, wrong, you failed), technical codes, cute openers, missing next step, fix not starting with a verb, length limits, missing way to reach a person on blocking errors. It does not write the copy for you.

Extract the design tokens a stylesheet actually uses. Pass `css` (free) or a public `url` (Pro; every linked and inline stylesheet is read). Returns colours (hex, with alpha kept, grouped as text, background, border), font families, font sizes, weights, line heights, spacing from margin, padding and gap, radii, shadows, z-index values, media-query breakpoints, and transition durations and easings, each with a use count and where it was used. Custom properties are resolved through var() chains, with light and dark values side by side and unused variables listed. Output includes a W3C design tokens (DTCG) tree of the custom properties and a markdown summary. Reads CSS text only: styles injected by JavaScript, computed styles and inline style attributes are not seen.

Pro. Fetch up to 10 public pages, run the static accessibility audit on each, and return a draft Accessibility Conformance Report in the shape of the ITI VPAT 2.5 WCAG edition: a report header (product, version, date, evaluation methods, contact, notes), then a table of every WCAG 2.2 Level A and AA success criterion (55, including 2.4.11, 2.5.7, 2.5.8, 3.2.6, 3.3.7 and 3.3.8; 4.1.1 Parsing is omitted because it is obsolete in 2.2). Each row has a Conformance Level of exactly Supports, Partially Supports, Does Not Support, Not Applicable or Not Evaluated, plus remarks. Rows are marked Does Not Support or Partially Supports only where the audit found a real issue, citing the page and the count. Rows that do not apply (no media, no forms, no drag or gesture code) are Not Applicable and state what was searched. Rows only a person can judge (keyboard use, focus order, captions quality, images of text) are Not Evaluated with a two-step test. Supports is used where the HTML, stylesheets and same-site scripts show no failure, and the remark states what was and was not checked. The report carries a disclaimer that it is a draft from automated checks and not a legal conformance claim, and a Manual testing still needed section. Pass `urls` (array, up to 10) or one `url`; productName, version, vendor, contactEmail and evaluator are optional header fields. Returns an object with `report` (markdown), `criteria` ([{criterion, name, level, remarks}]), `pages` and `counts`. Do not present the output to a customer as a finished VPAT.

Pro. List the saved project context, or read one item by name.

Explain what this server can do and suggest the three best first tasks for what the person has (a Figma link, a live URL, copy, a research plan, an event list). Use this first when the person is new or unsure what to ask for.

Build a Nielsen ten-heuristics review worksheet for a screen or flow. Give text (the copy of the flow), html or a url. Returns, for each heuristic, keyword and markup signals found or missing, review prompts, and blanks for findings and 0 to 4 severity. The signals point at where to look; a human evaluation is still required.

Inventory the components in a stylesheet and, if given, its markup. Pass `css` and optionally `html` (free), or a public `url` (Pro, which also reads the page markup). Classes are grouped into roles (button, card, input, badge, nav, alert, modal, avatar, tooltip) from their names, then variants are found from modifier classes (btn--primary, btn-lg, btn.primary). Reports each component family with its base properties and variants, inconsistencies across the same role (different corner radius, padding, font size, weight or height between families, or between variants that should match; size and shape variants are allowed to differ), naming collisions (btn and button both defined, for example) and properties set twice at the same level. With markup it also counts instances, common class combinations, inner structures, classes used but never styled and unclassed native buttons.

Check navigation or category labels. Give `labels` (one per line or comma separated). Flags catch-alls (Resources, Solutions, Misc), labels over 4 words, 'X and Y' labels, instruction words, all capitals, trailing punctuation, filler suffixes (hub, center, zone), duplicates and one-letter-apart near-duplicates, groups of labels with overlapping scope from a built-in set (support/help/contact, news/blog/press, products/solutions/services and others), mixed verb-led and noun labels, and mixed Title Case and sentence case. Wording checks only; test labels with people.

Check text against brand voice rules. Give text and rules (a string of plain lines, or a JSON object, or an array). Understood rules: banned words or phrases, preferred terms ('use sign in not log in', or 'log in -> sign in'), required capitalisation of product names, sentence case or title case for headings (markdown # lines or heading: prefixes), a maximum sentence length in words, banned punctuation (exclamation marks, em-dashes, ellipses, emoji, ampersands, all caps), required terms, and tone words to avoid ('tone to avoid: salesy'). Rules are parsed forgivingly and echoed back so a misread rule can be corrected. Returns violations with line number, offending text, the rule and a suggested replacement, plus the rules that never matched anything.

Lint design critique. Sorts each note into observation, opinion, solution-without-problem, vague, or question, explains what is missing, and gives an observation, impact, suggestion skeleton for weak notes. Reports the share of notes ready to act on.

Score a DESIGN.md (the brand and design context file models read before building): missing sections, no hex values, text and background pairs that fail contrast, too many typefaces, adjectives a model reads as the generic look, no never-list, no sizes, too long or too thin.

Lint financial, legal and consent copy (fees, rates, terms, privacy notices, error and decline messages) for plain language. Give text and optionally kind (fee, rate, terms, consent, privacy, error, marketing). Returns Flesch Reading Ease and Flesch-Kincaid grade (target grade 8 or lower), average sentence length, long words, passive voice, stacked negatives, legalese and jargon with plain replacements, vague money wording ('up to', 'as low as', 'may apply', 'certain fees') with why regulators dislike it, key terms buried after the first 150 characters or in long sentences, a per-kind checklist of missing elements, and draft rewrites for the worst sentences. A writing check, not legal or compliance advice.

Lint pasted email HTML. Checks: size against the roughly 102 KB point where Gmail clips a message, doctype, charset, viewport and lang, layout built on divs, flexbox, grid, float or positioning instead of tables (Outlook for Windows renders with the Word engine and ignores much modern CSS), background shorthand and background images (need VML and a colour fallback for Outlook), CSS variables, calc, rem/vw units, web fonts without fallback, <style> reliance without inline styles, container width (about 600 to 640 px is the convention), images without alt, width or display:block, image-only mail that goes blank when images are blocked, hidden preheader, color-scheme meta, small tap targets on button-like links, missing or odd unsubscribe link, JavaScript and forms, empty or http links. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.

Lint a Lottie (Bodymovin) animation. Pass `json` as the text of the .json file. Checks: valid JSON with the expected top-level fields (v, fr, ip, op, w, h, layers), text size (over about 100 KB is heavy for UI, over 500 KB is very heavy; conventions), layer count including pre-compositions, expressions (unsupported on several native players), embedded base64 images, masks, mattes, blend modes, 3D layers, text layers and effects (patchily supported on mobile players), frame rate (above 60 is wasted; above 30 rarely needed for UI), duration, and canvas size. dotLottie (.lottie zip) files are not supported; unzip first.

Lint user research questions, one per line, for leading wording, double-barrelled questions, hypotheticals, predictions, loaded words, jargon, closed questions in an open interview, why-questions and unlabelled rating scales, with a suggested rewrite for each problem.

Lint design token names from a list, CSS variables or a JSON token file: mixed separators, colours named by hue where roles belong, values or locations in names, version words, duplicate values, abbreviation drift (bg and background) and irregular scales.

Lint a product analytics tracking plan (event names with optional properties, one per line like 'project_created (template, source)') for mixed naming styles, vague events, UI-element names, near-duplicate events, tense and order drift, and personal data in property names. With no events and a productType (saas, ecommerce, marketplace, content, mobile) it drafts a starter plan.

Check source strings for translation readiness. Give `strings` (one per line, optionally 'key = text' and a trailing '[max 20]' limit), optionally `languages`, `maxChars` (a limit for every string) and `expansion` (your own factors, e.g. 'de=1.3, fr=1.25'; if omitted a default planning table of our own rough factors is used and named in the output). Projects length per language (short strings grow more), flags overflow against limits, and flags: fragments glued together, unnamed multiple placeholders, '(s)' plurals and counted nouns without a plural rule, 'a/an' before a placeholder, hard-coded dates, times, ordinals, currency and number separators, gendered pairs, left/right words, idioms, Latin abbreviations, markup, emoji and all-capital text. Pattern checks on English; character counts are not pixel widths.

Pick logo colourways per background. Give `colours` (brand palette: hex, rgb() or hsl(), optionally named, e.g. 'Ink #14213d, Paper #fff8ec, Flame #fca311'; first is the primary), optionally `logo` (the colours inside the full-colour logo, default the primary only) and `backgrounds` (default: each brand colour plus white and black). For each background it reports whether the full-colour logo reaches 3:1, and if not, which one-colour version (a brand colour, then white, then black) reaches 4.5:1 or at least 3:1, with ratios. Also suggests the set of colourways to produce.

Compute logo clear space and minimum sizes. Give width and height (any unit, pass `unit`), optionally `letterform` (height of a capital or the x-height in the same unit), `kind` (wordmark, lockup, symbol, monogram) and `clearSpaceMultiple` (default 1 letterform). Returns clear space on each side, the total exclusion zone, a compact clear space (half), minimum height and width for screen (smallest letterform 8 px) and print (1.5 mm), and a size table for common widths marking where the logo falls below the minimum. If `letterform` is omitted it is estimated and the result says so. The floors are conventions; your brand guide may differ.

Check line length and suggest leading. Pass `fontSizePx` and `containerPx` (the text column width in px). Optional: `charsPerLine` (use a counted value instead of the estimate), `language` (en, de, fr, es, it, pt, nl, ru, ja, zh, ko; sets the average character width), `avgCharWidthEm` (override, default 0.5). Returns the measure in characters, whether it is inside 45 to 75 (25 to 40 for CJK), a recommended line-height (about 1.4 at the short end rising to 1.6 at the long end, tighter for large type), paragraph spacing, and the container width that hits the range. The 45 to 75 range is Bringhurst's guidance (The Elements of Typographic Style) as cited in Smashing's Typography Best Practices; 1.4 to 1.6 line spacing is from UXPin's Principles of Visual Consistency. The leading curve is a convention. Width is an estimate from an average character, so it is a guide, not a measurement.

Build a modular type scale. Pass `base` (px, default 16) and `ratio` (a number from 1.01 to 4, or a name: minor second, major second, minor third, major third, perfect fourth, augmented fourth, perfect fifth, golden, major sixth, octave; default major third 1.25). Optional: `stepsUp` (default 6), `stepsDown` (default 2), `rootPx` (default 16), `minViewport` and `maxViewport` (defaults 320 and 1280), `minBase` and `minRatio` for the small-screen end of the fluid scale (default: same base, ratio pulled 20 percent toward 1). Returns each step with px, rem and a clamp() expression that interpolates linearly between the two viewports, plus fixed and fluid CSS custom properties. The ratio names come from music intervals and are a web design convention, not a law; Bringhurst, The Elements of Typographic Style, discusses scales of related sizes. Pure calculation, nothing is stored.

Screen brand name candidates. Give `names` (1 to 30) and optionally `existing` (names to compare against: competitors, your own brands) and `tld` (default com). For each name: letters, syllables, length note, pronunciation or typing hazards (silent letters, consonant stacks, digits, symbols, accents, camel case), spelling-ambiguity patterns with a low, medium or high risk of being misspelled after being heard, a domain-friendly form (availability is NOT checked), and close matches by edit distance, simple sound-key and containment against `existing` and the other candidates. This is a language and usability screen only: it makes no trademark, legal or availability claims and does not check meaning in other languages.

Analyse a navigation tree. Give `tree` as indented text (2 or 4 spaces or tabs, bullets optional, or 'A > B > C' paths) or JSON (nested {label, children} objects, arrays or a key-value map). Optionally `maxDepth` (default 4), `maxBreadth` (default 9) and `pages` (pages or labels that should be reachable, to find orphans). Returns node and leaf counts, depth, nodes and average children per level, the widest branch, items deeper than the limit, branches wider than the limit, one-child branches, naming collisions (siblings with the same name, the same name in different branches, a child repeating its parent), and orphans. Structural checks only; limits are conventions and there is no magic number.

Check notification copy. Give `notifications`, one per line as 'title | body' with an optional channel prefix (push:, email:, inapp:, sms:), and `channel` for the default (push). For email, title is the subject and body the preheader; for sms the whole line is the message. Flags: missing title or body, length beyond approximate truncation (push 45/110, email 50/100, in-app 60/140, SMS 160) with a preview of what stays visible, generic text, urgency language, all capitals, exclamation marks, emoji, no specific name, number or time, greeting openers, label prefixes, title repeating body. Truncation varies by device; the numbers are approximate.

Audit how numbers are displayed. Pass `numbers` (the strings exactly as shown, as a list or newline or comma-separated text; JSON numbers lose their formatting so strings are better), `context` (axis, tooltip, table cell, headline), and optionally `locale` (en-US, de-DE, fr-FR and so on), `raw` (the unrounded values in the same order, to test whether rounding creates ties or reverses the ranking) and `total` (a stated total to compare with the displayed parts). Checks: consistent decimal places, mixed thousands or decimal separators, the ambiguity of a lone separator before three digits (1,000 versus 1.000), missing grouping on long numbers, mixed k, M, B suffixes and the lowercase m trap, mixed or repeated units and currency, negative-number styles, right-alignment and tabular figures for table cells, uneven axis ticks, false precision, and rounding that changes ranking or breaks a sum. Returns findings and, where the set is uniform enough, a suggested reformatting. Pure computation.

Weighs a public page from its delivered HTML. Pass `url`. Reports HTML bytes (uncompressed, plus the server's reported transfer length when given), element count, link count and distinct link targets, image count with lazy-loaded and no-dimension counts, iframes, media, inline style and script bytes, and the number and uncompressed size of linked stylesheets and scripts (up to 10 stylesheets and 20 subresources are fetched, each up to 3 MB). Warns on thousands of links, large HTML, large DOM, many images or scripts. Reads up to 5 MB of HTML; if it stops early it says so, states how many bytes it read and what share of the page that is when the size is known, and treats every count as a minimum. Does not run script, so content added at runtime, images, fonts and media sizes are not included.

Build colour harmonies from base colours. Pass `colors` (one to six colours as hex, rgb(), hsl() or CSS names, comma or newline separated, or an array) and optionally `harmony` (complementary, analogous, triadic, split-complementary or tetradic) to return one scheme. Hue is rotated in OKLCH with lightness and chroma held, so the set is evenly weighted; colours that cannot hold the chroma inside sRGB are reduced and marked. Returns hex and oklch() for each colour, a note on which harmony suits which job, and a list of near-duplicates (OKLab distance under 3, a working convention). Near-grey bases have no hue and are flagged. OKLCH opposites differ from the red-yellow-blue paint wheel. Pure maths, nothing stored.

Check text for plain language. Give `text`, optionally `targetGrade` (default 8) and `jargon` (your own words to flag). Returns Flesch Reading Ease, Flesch-Kincaid grade, rough reading age (grade plus 5), average sentence length, passive sentence count, sentences over 25 words, jargon and formal words with plain replacements (about 70 built in), wordy phrases ('in order to' -> 'to'), stacked negatives, and the worst sentences with reasons. English only; syllable counts are rule-based so grades are estimates.

Builds an export plan. Pass `assets` as lines like `search-icon | 24x24 | icon | web, ios, android` or as a JSON array of {name, width, height, kind, platforms}. Kinds: icon, logo, illustration, photo, ui, background, favicon, app-icon, og-image, sprite. For each asset returns the recommended format (SVG for vector kinds, AVIF or WebP with JPEG fallback for photos, PNG for flat UI), web 1x to 3x sizes, iOS @2x and @3x, Android mdpi to xxxhdpi sizes (1, 1.5, 2, 3, 4 times), favicon and PWA sizes, adaptive icon geometry, the 1200x630 social card, and warnings for fractional or odd sizes. Rules of thumb that change over time; confirm against current platform docs. Computes sizes only and produces no files.

Plan responsive breakpoints from content. Pass `contentWidths` (list of px widths where your layout starts to fail or needs to change, found by dragging the browser or frame), and optionally `deviceTargets` (px widths of devices you must support; these are checked against the result, never used to create breakpoints), `minMeasure` (default 45 characters) and `maxMeasure` (default 75) for text columns, `fontSize` (default 16), `gutter` (default 24), `margin` (default 24), `maxColumns` (default 3), and `fluidMin` and `fluidMax` (viewport range for the fluid rules, default 320 and 1440). Returns breakpoints (your content widths plus widths derived from how many columns at the minimum measure fit, and where one column reaches the maximum measure), a container max-width for each, ready CSS, fluid clamp() rules for body size, h1, gutter and page padding computed so they hit exact minimum and maximum at the range ends, a note for any two breakpoints within 10% of each other, and for each device target whether it is already near a breakpoint. Sources: Marcotte, Responsive Web Design (breakpoints follow the design). The 45 to 75 character measure, the 0.5em average character width and the 10% closeness test are conventions. Pure arithmetic, nothing stored.

Plan a design critique for a stage (concept, wireframe, visual, prototype, build, shipped): a framing statement, timed agenda, the questions that fit the stage, roles, and the kinds of feedback to turn away until a later stage.

Plan animation durations. Pass `distance_px` (how far the thing moves, 0 to 5000), `size` (small, medium, large, fullscreen), `complexity` (simple, moderate, complex) and optionally `kind` (enter, exit, state-change) and `allow_long` (true to lift the 400 ms UI cap for decorative or page-level motion). Returns a recommended duration, the enter and exit pair, a five-step token scale and the rationale. The formula is our own heuristic (stated in the output), shaped by common practice; it is an estimate to tune by eye, not a standard.

Models sequential keyboard navigation for WCAG 2.4.3 Focus Order, 2.1.1 Keyboard, 2.4.1 Bypass Blocks, 2.4.7 Focus Visible and 4.1.2 Name, Role, Value. Pass `markup` (HTML with optional style blocks). Returns the numbered Tab sequence with guessed accessible names (aria-label, label, text, alt, title), the elements left out (hidden, inert, tabindex -1), and findings: positive tabindex, focusable elements inside aria-hidden, onclick on non-interactive elements, controls with no name, no skip link, outline: none without a replacement, and dialogs that need manual testing. It is a model of the browser rule from attributes, not a recording; Reads the pasted source only; nothing is rendered or run, stored or logged.

Plan imposition for a booklet or book. Pass `pages` (1 to 1024) and `binding`: saddle (stitched; one nested stack, pages in multiples of 4), perfect or sewn (gathered signatures of `signature` pages: 4, 8, 16, 32 or 64; 16 is the common offset size). Returns pages after padding to the next multiple, blank pages to add, number of signatures or sheets, and for saddle the printer-spread pairs for every sheet (outer and inner sides). With `caliper_microns` it estimates creep for saddle stitch: the sheet nested k sheets inside the outermost shifts its content outward by about k x caliper, so planned inward compensation for the outermost sheet is about (sheets - 1) x caliper. Printers use their own creep tables, and some compensate with 2 x caliper; treat this as an estimate.

Plans responsive images. Pass `breakpoints` as min-viewport:width pairs such as `0:100vw, 768:50vw, 1200:600px` (vw or px), and optionally `dprs` (default 1,2), `sourceWidth` (original pixel width, upscaled candidates are dropped), `format` (jpeg, webp, avif, png; default webp), `aspect` (16:9 or 1.5, adds a height for layout stability), `urlPattern` containing {w}, `aboveFold` (true adds fetchpriority high and no lazy loading), `maxViewport` (default 1920) and `content` (photo, graphic or noisy). Returns the srcset widths (thinned so neighbours differ by at least 18 percent, max 8), the sizes string, an <img> tag, and a rough byte estimate from typical bits per pixel for the format. Estimates are within about 2x either way. It plans markup; it does not resize files.

Plan staggered reveals. Pass `count` (1 to 200), `duration_ms` (each item's own duration, default 300), `pattern` (linear, ease-out, ease-in, center-out, edge-in, scattered), optional `step_ms` (gap between items) and `budget_ms` (cap on the whole sequence, default 600, a convention). Returns the delay for every item, total time, the step actually used, a CSS custom-property snippet for linear patterns, and warnings (a step under one frame at 60 Hz is invisible; very long lists should animate in groups).

Plans for translation growth. Pass `strings` (one UI string per line), optionally `languages` (two-letter codes from de, fr, es, pt, it, nl, ru, pl, fi, tr, vi, id, ar, he, hi, th, ja, ko, zh; default de, fr, es, ru, fi, ja, ar) and `maxChars` (the character capacity of your container). For each string returns the planned character range per language and the worst case, and flags strings that exceed maxChars. Short strings expand proportionally more than long ones, so the table applies a length boost. Factors are rule-of-thumb ranges for ordinary UI copy (convention), not measurements; CJK shrinks in characters but can grow in width and height. Run real translations before locking a layout.

Build a usability test plan skeleton with fixed template logic (no model call). Pass `goal` (what you need to learn), `participants` (a number, a list of criteria, or {count, groups, profile}) and `tasks` (strings, or {name, scenario, start, success}). Optional: `product`, `method` (moderated or unmoderated), `session_minutes`. Returns a screener built from your criteria, a session outline, each task checked for leading wording (naming buttons or menus, 'click', 'easily') with a scenario shape, start point, success and stop rules, metrics (completion, time, errors, Single Ease Question, problem log), a sample-size note that explains the five-user model (1 - (1 - L)^n) and its limits, and a markdown note-taking sheet. Draws on general practice from Krug, Cooper's About Face and Norman. The leading-wording check is a keyword heuristic. The five-user figures are a convention from the usability literature, not verified against the design library.

Get a prepress checklist tailored to the job. Pass `product` (flyer, brochure, book-perfect, book-saddle, business-card, poster, packaging, large-format), `colour` (cmyk, cmyk-spot, black-white) and optionally `finishes` (comma-separated: spot-uv, foil, emboss, die-cut, varnish, lamination, perforation, fold). Returns grouped checks: document setup, colour, images, type, finishing files, export and delivery, with the figures to confirm with your printer. Items are common practice; the printer's own spec sheet always wins.

Lookup for the gap between what our static tools read and what a browser renders. Pass `finding`: a finding or tool name (for example "unnamed link", "alt text", "contrast", "touch targets", "duplicate landmark", "aria-hidden", "carousel") or a WCAG number. Returns when the static result over-reports, when it under-reports, how far to trust it, and a ready-to-run Puppeteer or DevTools snippet for the rendered check. With no `finding`, lists every id. Deterministic table; nothing is fetched or run.

Finds repetition that makes a page harder to scan by ear. Pass a public `url` or `html`. Reports: a heading and a link with the same text in the same region or close in reading order (for example a section heading and a "see all" link with the same words); duplicate heading text within a region; links with the same text going to different destinations; the same link repeated to one destination; multiple navigation, complementary, region or search landmarks without distinct names; more than one main, banner or contentinfo; and duplicate id values. Headings and links that are aria-hidden or hidden are skipped, because a browser leaves them out of the accessibility tree, and the count of skipped items is stated. Reads delivered markup only: CSS-hidden duplicates (desktop and mobile navs), shadow DOM and script-built content are not handled.

Review a described animation against the twelve animation principles (squash and stretch, anticipation, staging, pose to pose, follow through, slow in and slow out, arcs, secondary action, timing, exaggeration, solid drawing, appeal). Pass `description` (what moves, how, how long, why) and optionally `purpose` (ui, marketing, illustration). Keyword-based: a principle marked 'not mentioned' may still be present in the design, and one marked 'mentioned' is not proof it is done well. Each principle comes with a question to answer and how it translates to interface motion. Also flags stated durations over 400 ms for UI.

Reviews text for formats that do not travel across locales. Pass `text` and optionally `locales` (BCP 47 tags, comma-separated) and `currency` (ISO 4217 code, default USD). Flags numeric dates that could be day-first or month-first, English month-first dates, ordinals like 4th, mixed 12 and 24 hour clocks, comma versus period grouping used together, symbol before and after amounts, bare $ signs, percent spacing, imperial units, hard-coded plurals such as item(s) and 'x days ago', and US phone formats. Then prints a table of a fixed date, number and currency amount in each locale using the runtime's Intl data, so you can see what the same value looks like. English text patterns only; Intl output can vary a little by platform version.

Reviews a language or region switcher. Pass `locales` as markup (a <select> with options, or a list of links with hreflang or lang) or as lines such as `de: Deutsch`. Flags flag emoji or flag imagery standing in for languages, options named in English instead of their own language (autonym), options shown only as a code, missing lang on options (WCAG 3.1.2 Language of Parts), invalid BCP 47 tags, labels that differ from the usual autonym in a built-in table of about 30 languages, RTL options without dir, duplicates, unsorted long lists, a select that navigates on change (WCAG 3.2.2 On Input), an unlabelled select (4.1.2), and language mixed with region. Static; it does not load the target pages.

Review interface strings. Give `items`, one per line, each prefixed with its type: button:, link:, label:, tooltip:, empty:, confirmation:, placeholder:, heading:. Type-specific checks: buttons and links (starts with an action verb, generic labels like OK or Submit, 1 to 3 words, 'click' wording, link text out of context), labels (short, noun-like), tooltips (length, not repeating the control), empty states (says why and offers a next step), confirmations (names what happened or will happen, 'Are you sure?', yes/no buttons). All types: vague error wording, filler, 'please', interjections, technical codes, all capitals. Findings are rated high, medium or low. Pattern checks on single strings in English.

Review interface copy, one string per line, optionally prefixed with a type (button:, error:, empty:, tooltip:, placeholder:, heading:, toast:, label:). Checks each string for what its type needs (errors say what to do, empty states give a next step, buttons name the outcome), checks the set for inconsistency, and runs AI-writing tells over everything.

Pro. Save named project context (brand notes, a DESIGN.md, past decisions, personas) against the Pro key, up to 20 items of 50,000 characters, so later sessions and prompts can reuse it.

Scan text for real personal and secret data that should not appear in design files, and return a masked report plus a redacted copy. Pass `text` (for example every text layer from a Figma frame, a spec, mockup sample data or OCR text from a screenshot) and optionally `mode`: design (default) or strict, which also flags capitalised full names next to labels like Customer. Detects emails (example.com/org/net and test/invalid TLDs are treated as safe), phone numbers (fictional 555-01xx and Ofcom drama ranges are safe), payment cards checked with Luhn (public test cards such as 4242 4242 4242 4242 are safe), IBANs checked with mod-97, US SSNs (invalid ranges ignored), UK National Insurance numbers, IPv4 and IPv6 addresses outside documentation ranges, AWS, Stripe, GitHub, Slack, Google, Anthropic and OpenAI keys, JWTs and private key blocks, and lower-confidence street addresses and labelled dates of birth. Each finding has type, masked preview (never the full secret), line, confidence and a safe placeholder; `redacted` is the input with every finding replaced. The text is processed in memory, never stored or logged. Use it as the last step before sharing a file.

Score a design system from its CSS. Pass `css` and optionally `html` and `pairs` (free), or a public `url` (Pro). The score is out of 100 and weighted: tokens 25 (share of colour, size, spacing, radius and shadow declarations that go through a variable, full marks at 60%, scaled down below 8 custom properties), scales 25 (mean of colour, type, spacing and radius discipline), components 20 (penalty of 0.20, 0.10 and 0.03 per high, medium and low inconsistency), state coverage 20 (focus-visible weighted 0.5, hover 0.25, pressed and disabled less, minus 0.15 per outline removed without a replacement) and contrast 10 (share of text and background pairs reaching 4.5:1; pairs are taken from rules that set both colours, plus any you state as `pairs`, a list of {foreground, background, label} or lines such as "#767676 on #ffffff"). An area with nothing to measure is left out and the others are rescaled. The result shows each area's points, the basis, and a ranked fix list with the points each fix would recover.

Read HTML (pass `html`, or a public `url`) and return a linear approximation of what a screen reader announces, in document order: landmarks, headings with levels, links, buttons, form controls with accessible names and states (required, expanded, checked, disabled and more), images with alt, lists and tables. Accessible names are computed in a simplified way (aria-labelledby, aria-label, label for or wrapping label, alt, title, text content); aria-hidden, hidden and inline display:none are honoured. Problems are flagged inline: no accessible name, generic link text, duplicate landmark with no label, skipped heading level, name from placeholder only, missing alt, table without header cells. Output is capped at the first 250 nodes, with a count of those omitted. This is an approximation of the accessibility tree built from static markup, not a recording of NVDA, JAWS or VoiceOver; it does not run script or apply stylesheets. Returns an object with `report` (the script as text), `nodes` and counts.

Pro. Score a site in one call. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Runs the inventory, meta, heading and link health checks over the same crawl and returns a 0 to 100 score per area (each check has a weight; points lost are weight times the share of pages or links affected; the formula is printed in the result), an overall average, and the top 10 issues. Optional `maxLinkChecks` lowers the link check cap.

Pro. Find templates that drift. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Treats the most common version of each area as the baseline and lists the pages that differ: primary nav links, header and footer markup, footer links, stylesheet set, h1 class, button and link text written several ways, html lang and icons.

Pro. Check heading structure across a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Returns each page's heading outline, pages with no h1 or more than one, skipped levels, empty headings, duplicate titles and h1s, and a site-wide table.

Pro. Map a site into page types. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Returns page-type groups (by URL pattern and template markers) with counts found and read, depth, orphan hints from sitemap and link comparison, and a pages.md style table with one verified URL per type that other audits can take as input.

Pro. Check the links on a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Collects internal links from the pages read, requests up to 60 destinations not already crawled (HEAD first, GET if HEAD fails), and reports non-2xx results, redirects (final URL only; hop counts are not visible), links to http, links with no name, vague link text, one text pointing to different places, and links with no destination. Links with aria-hidden=true are not counted as unnamed. Optional `maxLinkChecks` lowers the check cap.

Pro. Audit head metadata across a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Checks title and description presence, length and duplicates, canonical links that point elsewhere, html lang, viewport, og and twitter tags, robots meta noindex, hreflang validity and icon links.

Pro. Fetch two public pages (`url` and `compareUrl`, which must differ; use it for staging against production) and return a structural diff: metadata, landmarks, headings, links, images, stylesheets and scripts (same-host links compared by path), text length, and the change in static accessibility findings. Obeys robots.txt for the user agent ATPDesigners and opens with coverage.

Pro. Spot static performance problems across a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Reports HTML size, stylesheets and scripts that block rendering in the head, images without width and height or loading=lazy, inline @font-face without font-display, Google Fonts URLs without display, font preloads without crossorigin and third-party origins without preconnect. It never measures time and makes no speed claims; linked CSS and JS files are not fetched.

Convert a sitemap into an outline. Give `input` as a list of URLs or paths (one per line; query strings and fragments are dropped) or an indented tree, and optionally `format` (numbered, markdown, indent). URL lists are folded into a tree under Home, with labels guessed from slugs (placeholders for real titles). Returns the outline plus notes: sections that exist only as parents of other URLs (no page of their own), ID segments that need names, depth over 4, a branch with more than 9 children, and single-child sections. Up to 2000 lines.

Stress-test UI strings for translation. Give strings (one per line, optionally 'text | maxChars' or 'label | text | maxChars', or a JSON array of {text, maxChars, label}), optional locales (default de, fr, es, fi, ru, ja, ar, zh) and optional defaultMaxChars. Applies the published IBM translation expansion guidance by string length (up to 10 chars about +200 to 300%, 11 to 20 about +80%, 21 to 30 about +60%, 31 to 50 about +40%, 51 to 70 and over 70 about +30%), adjusted per locale (CJK contracts to about half, German and Finnish run longer than French). Predicts expanded length, flags strings that overflow their limit, generates a pseudo-localised version, and flags concatenated fragments, variables that need ordering freedom, hard-coded dates, numbers, currency and plurals, text-in-image risks, and right-to-left mirroring notes. Estimates from published ratios, not translations.

Review taglines. Give `taglines` (1 to 25, one per line), optionally `brand` (to flag repeating the name) and `cliches` (extra phrases to flag). Checks word and character count, about 90 stock phrases and fillers, abstract words, three-item lists, 'where X meets Y' constructions, exclamation marks, and concreteness (numbers or named things). Returns a 0 to 100 concreteness score per line, issues, and a flag when the line could be used by any competitor. A heuristic aid; it does not check uniqueness or legal status.

Find overlaps in tags and categories. Give `tags` and/or `categories` (or `terms`), one per line, optionally with usage counts as 'term (12)'. Groups terms that are the same once case, plurals and punctuation are ignored, same words in a different order, differing by spacing or hyphen, or one or two letters apart; says when a group spans both lists; suggests the most-used (else shortest) term to keep; lists possible parent and child pairs where one term's words are all inside another's; and lists terms used once or never when counts are given. Matching is by spelling, so true synonyms need a human.

Generate a 50, 100, 200 ... 900, 950 scale from one `color` (hex, rgb(), hsl() or a CSS name) and optionally a `name` for the CSS variables. Your colour is kept exactly on the step nearest its own lightness; other steps follow a fixed OKLCH lightness curve with the hue held and chroma tapering toward the ends (reduced where sRGB cannot hold it). Each step reports hex, oklch(), WCAG contrast against white and against black, and whether it passes 4.5:1 as text on each. Also returns the lightest step that passes as text on white, the lightest that passes as text on black, any step that passes both, and a CSS custom-property block. Contrast is WCAG 2.x relative luminance.

Static estimate of the rendered size of interactive elements (a, button, input, select, textarea, summary, role=button/link, onclick) for WCAG 2.5.8 Target Size (Minimum, 24px) and the 44px guidance. Pass `html` and `css`, or a public `url` (page plus up to 12 stylesheets). It matches CSS rules to elements, uses explicit width/height/min sizes, padding, border, line-height and font-size (with browser defaults for form controls), guesses text width, reads margins and gap including li > a wrappers, and decides whether a neighbouring control exists. Output groups elements by kind with a status: fail-estimate, under-24-isolated, under-24-spaced, inline (exempt inside a sentence), unknown (icon-only with no stated size) or ok. Optional `viewport` (default 390) selects media queries. States plainly that it is an estimate and includes a Puppeteer snippet for the rendered measurement. It does not apply state, sibling or structural selectors, transforms, container queries or script-set sizes.

Score tree test (findability) data. Give `results` as CSV with a header row and one row per participant per task, with columns task, success (yes/no or 1/0), and optionally direct (reached the answer without backtracking), first_click (the top-level label clicked first), time (seconds). Optionally `expectedFirstClicks` as lines 'Task name = Label, Label'. Returns per task: participants, success rate with 95% Wilson interval and a band (80+ strong, 60 to 79 mixed, under 60 weak, our rule of thumb), directness, direct-success rate, first-click distribution and the share on expected labels, median time, and notes (small sample, success that needed backtracking, wrong first clicks). Reports skipped rows rather than failing.

Answer the six questions of Steve Krug's trunk test (Don't Make Me Think) from a page's markup: what site is this, what page am I on, what are the major sections, what are my options at this level, where am I in the scheme of things, how can I search. Pass a public `url` (fetched safely, public hosts only) or `html`/`text` (pasted markup or page text). Looks at the title tag, site name meta, header logo and home link, h1, nav landmarks, breadcrumb markup and BreadcrumbList data, aria-current and active classes, and search forms. Each question comes back answerable, partial or missing with the evidence found. Reads static markup only: it cannot see layout, prominence, script-built menus or how the page looks at arm's length, so it supports the real paper test and does not replace it.

Lint text, HTML or CSS for common typographic errors. Pass `text` (plain copy, an HTML fragment or a stylesheet) and optionally `kind`: auto (default), text, html or css. Checks: two spaces after a period, repeated spaces, straight double quotes and apostrophes where curly belong, hyphen or double hyphen used as a dash, hyphen in a numeric range (use an en dash, no spaces), spaced en dash in a range, three periods for an ellipsis, spaced-out lowercase, all-caps runs, widow hints, synthesised or fake small caps, letterspaced lowercase, capitals without tracking, uppercase body text, body line-height under 1.2, justified text without hyphens, four or more typefaces, bold or italic with no font files or font-synthesis setting, and no text-wrap rule. Each finding has rule, severity (high, medium, low), line, excerpt, message, fix and basis (the book it traces to, or convention). Sources: Lupton, Thinking with Type (sentence spacing, quotes, dashes); Bringhurst, The Elements of Typographic Style; Smashing eBooks, Typography Best Practices (small caps, faux styles, justification, widows). Thresholds such as the 1.2 line-height floor and the typeface count are conventions. Static checks only; code and pre blocks are skipped.

Check a font pairing against a built-in table of about 55 common families (Helvetica, Arial, Inter, Roboto, Open Sans, Lato, Georgia, Times New Roman, Garamond, Caslon, Jenson, Palatino, Baskerville, Playfair Display, Bodoni, Trade Gothic, Futura, Knockout, Champion Gothic, Oswald, Courier New, JetBrains Mono and others, plus common aliases). Pass `fonts`: two or three names, optionally with a role as "Name:role" (heading, body, code, ui, display, caption; default order is heading, body, code). Returns each face's class (serif, sans, mono, display, script) and structure, how the pair contrasts (same class and structure reads as too similar, serif with sans as clear contrast), x-height and width warnings, role problems (display face for body, high-contrast face at text size, monospace prose), and a verdict: works, works with adjustments, risky or incomplete. A family not in the table is reported as unknown with no verdict for it. Table values are qualitative and approximate. Ideas: Lupton, Thinking with Type (contrast of structure when combining faces); Cullen, Layout Workbook (compare x-height and cap height); Smashing eBooks, Typography Best Practices (short x-height at small sizes).

Review pasted URLs or paths (no fetching). Give `urls`, one per line, up to 500. Reports trailing slash mix, capital letters (paths are case-sensitive on many servers), mixed word separators (hyphen, underscore, camelCase), run-together words, file extensions, opaque ID segments, query parameters, session IDs, encoded characters, double slashes, depth (more than 4 segments), segments over 40 characters, years in paths, www/non-www and http/https mixing, URLs that differ only by case, slash or separator, singular/plural twins of one section, and an overall percentage of readable segments. Pattern checks on the strings only; it cannot see redirects.

Usability arithmetic with formulas shown. mode sus: score System Usability Scale responses (rows of ten 1-5 answers) with grade, percentile and 95% interval. mode discovery: participants needed to find a share of problems (Nielsen and Landauer). mode ab: sample size per variant for a conversion test (baseline, lift in percent, optional dailyVisitors). mode survey: responses needed for a margin of error.

Snap a type scale to a baseline grid. Pass `baseline` (px, default 8) and `sizes`: an array of pixel sizes, or "name:size" strings such as "h1:48" and "body:16". Optional: `bodySize` (default 16) and `rootPx` (default 16). Returns, per size, a line-height rounded to a whole number of baseline units (never under 1.1 times the size), margin-block start and end in baseline multiples, and CSS using calc(var(--baseline) * n). Preferred ratios fall as size rises (1.5 up to 18px, 1.35 up to 28px, 1.25 up to 40px, then 1.15); that curve and the margin pattern are conventions, with body leading in line with UXPin's 1.4 to 1.6 and vertical rhythm as a composition aid per Smashing's Typography Best Practices. Aligns line boxes and margins; it does not read font metrics.

Show the caller's plan (Free or Pro) and how many calls remain today on each tool. Does not use up a daily call.

Builds a changelog from two lists. Pass `before` and `after` as lines (`name: value` or just `name`) or JSON (flat or nested objects, W3C-style tokens with $value, or arrays of names). Returns added items grouped by prefix, changed values phrased with the real change (colour from-to, pixel difference), probable renames guessed from similar names or identical values (confirm each), removed items, counts, and a suggested semantic-version bump (removals and renames suggest major, additions minor, value changes patch; a convention). Optional `version` and `title` head the output. It compares only the text you give it and cannot see visual changes that are not in the lists.