Designers
Checks, prompts and skills for designers working with AI: contrast, a11y, heuristics, critique.
| Endpoint | https://designers.allthepossibles.com/mcp (streamable-http) |
|---|---|
| Registry version | 1.0.0 |
| Now | 141 tools · grade D (52) · pin ts_b41e1702584b011bc15b7812d4813cd4 · protocol 2025-06-18 |
| First / last listed | 2026-10-24 20:14 UTC / 2026-10-24 20:14 UTC |
| Grade over time | 2026-10-24: D (52), 141 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: check_contrast audit_page_accessibility heuristic_worksheet detect_design_slop review_ui_copy lint_design_feedback plan_critique lint_research_questions usability_stats lint_tracking_plan audit_site_accessibility check_contrast_tokens build_heuristic_report getting_started whoami check_touch_targets lint_token_names lint_design_md doctor save_project_context get_project_context generate_conformance_report screen_reader_script check_motion audit_email_accessibility check_reflow lint_disclosure_copy audit_dark_patterns lint_brand_voice stress_test_localisation scan_pii check_design_drift audit_form modular_scale measure_leading type_crimes_lint vertical_rhythm type_pairing_check build_grid build_spacing_scale calculate_proportion plan_breakpoints check_proximity_alignment palette_harmony tint_shade_scale color_meaning_check dark_mode_palette colour_temperature_mix trunk_test check_form analyse_card_sort calc_fitts_hick plan_usability_test chart_lint chart_chooser chart_colour_check data_table_vs_chart number_format_check css_contrast_pairs alt_text_quality error_message_check touch_target_css page_weight_report repeated_label_check rendered_vs_static_notes site_inventory site_heading_outline site_meta_audit site_link_health site_consistency site_page_diff site_performance_hints site_audit_summary extract_design_tokens audit_token_scales audit_type_scale audit_spacing inventory_components check_state_coverage score_design_system compare_token_sets dtcg_to_css css_to_dtcg draft_brand_checklist design_easing plan_durations audit_motion_css plan_stagger review_animation_principles lint_lottie_json lint_email_html check_email_preheader check_email_dark_mode check_email_accessibility check_email_subject calc_print_spec calc_print_resolution check_colour_mode convert_paper_size plan_imposition print_file_checklist approx_print_colour logo_size_rules logo_contrast_variants brand_voice_consistency naming_check tagline_review brand_architecture_planner colour_palette_brief_check review_microcopy error_state_writer_template content_hierarchy_check plain_language_check localisation_readiness button_label_consistency notification_copy_check nav_depth_check label_clarity_check url_structure_review taxonomy_overlap tree_test_scorer sitemap_to_outline cognitive_load_check check_reading_order plan_focus_order check_keyboard_shortcuts check_input_modality check_rtl_readiness check_font_coverage review_date_number_formats plan_text_expansion check_name_fields check_cjk_line_breaking review_locale_picker check_handoff_spec check_naming_conventions plan_asset_exports plan_responsive_images audit_icon_set check_svg_bloat write_design_changelog
check_contrast | 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. params: fg, bg, sizePx, bold, pairs, palette |
audit_page_accessibility | 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 a params: url, html, compareUrl |
heuristic_worksheet | 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. params: text, html, url, task |
detect_design_slop | 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. params: url*, compareUrl |
review_ui_copy | 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. params: text, items |
lint_design_feedback | 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. params: text* |
plan_critique | 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. params: description*, stage*, goal, audience, minutes |
lint_research_questions | 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. params: text*, mode |
usability_stats | 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 params: mode, responses, p, target, baseline, lift, alpha, power, dailyVisitors, margin, confidence, population |
lint_tracking_plan | 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. params: text, events, productType |
audit_site_accessibility | 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. params: url*, maxPages |
check_contrast_tokens | 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. params: tokens* |
build_heuristic_report | 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. params: title, task, findings* |
getting_started | 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. params: have |
whoami | Show the caller's plan (Free or Pro) and how many calls remain today on each tool. Does not use up a daily call. params: none |
check_touch_targets | 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. params: targets, text |
lint_token_names | 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. params: text* |
lint_design_md | 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. params: text* |
doctor | 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 triggeri params: symptom, client, figmaLink |
save_project_context | 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. params: name*, content* |
get_project_context | Pro. List the saved project context, or read one item by name. params: name |
generate_conformance_report | 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 omi params: urls, url, productName, version, vendor, contactEmail, evaluator |
screen_reader_script | 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 fo params: html, url |
check_motion | 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 scr params: html, css, url |
audit_email_accessibility | 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, params: html* |
check_reflow | 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 params: html, css, url |
lint_disclosure_copy | 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 replace params: text*, kind |
audit_dark_patterns | 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 params: text, html, url |
lint_brand_voice | 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 punctu params: text*, rules* |
stress_test_localisation | 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 params: strings*, locales, defaultMaxChars |
scan_pii | 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.co params: text*, mode |
check_design_drift | 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, params: design*, code* |
audit_form | 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, pa params: html, url, errors |
modular_scale | 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 params: base, ratio, stepsUp, stepsDown, rootPx, minViewport, maxViewport, minBase, minRatio |
measure_leading | 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 re params: fontSizePx*, containerPx*, charsPerLine, language, avgCharWidthEm |
type_crimes_lint | 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 ran params: text*, kind |
vertical_rhythm | 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 ca params: baseline, sizes*, bodySize, rootPx |
type_pairing_check | 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 rol params: fonts* |
build_grid | 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 width params: width*, columns, gutter, margin, rows, height, rowGutter, baseline |
build_spacing_scale | 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 params: base, ratio, steps, count, prefix |
calculate_proportion | 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 a params: width, height, ratio, orientation, container |
plan_breakpoints | 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 colu params: contentWidths*, deviceTargets, minMeasure, maxMeasure, fontSize, gutter, margin, maxColumns, fluidMin, fluidMax |
check_proximity_alignment | 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 params: boxes, html, css, tolerance |
palette_harmony | 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 sR params: colors*, harmony |
tint_shade_scale | 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 agains params: color*, name |
color_meaning_check | 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 pro params: states* |
dark_mode_palette | 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 v params: tokens* |
colour_temperature_mix | 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 params: colors* |
trunk_test | 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, heade params: url, html |
check_form | 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 params: url, html |
analyse_card_sort | 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 h params: participants*, threshold |
calc_fitts_hick | 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 params: distance, width, choices, layouts, fitts_a, fitts_b, hick_a, hick_b |
plan_usability_test | 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 t params: goal*, participants, tasks*, product, method, session_minutes |
chart_lint | 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, params: spec* |
chart_chooser | 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), params: question*, categories, points, series, thirdVariable, hierarchy, overTime, audience |
chart_colour_check | 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 ( params: colors*, background, chartType |
data_table_vs_chart | 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, a params: rows*, cols*, purpose*, precision, space, timeSeries, mixedUnits, groups, audience |
number_format_check | 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) params: numbers*, context*, locale, raw, total |
css_contrast_pairs | 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, resol params: url, css, html, scheme, viewport |
alt_text_quality | 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 a params: url, html |
error_message_check | 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 params: messages* |
touch_target_css | 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 brow params: url, html, css, viewport |
page_weight_report | 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 2 params: url* |
repeated_label_check | 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; mu params: url, html |
rendered_vs_static_notes | 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 params: finding |
site_inventory | 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 UR params: url*, paths, maxPages, sitemap |
site_heading_outline | 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 params: url*, paths, maxPages, sitemap |
site_meta_audit | 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 descrip params: url*, paths, maxPages, sitemap |
site_link_health | 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 params: url*, paths, maxPages, sitemap, maxLinkChecks |
site_consistency | 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 o params: url*, paths, maxPages, sitemap |
site_page_diff | 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. params: url*, compareUrl* |
site_performance_hints | 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 HTM params: url*, paths, maxPages, sitemap |
site_audit_summary | 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 params: url*, paths, maxPages, sitemap, maxLinkChecks |
extract_design_tokens | 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, params: css, url |
audit_token_scales | 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 betw params: css, url, values |
audit_type_scale | 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 params: css, url |
audit_spacing | 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 co params: css, url |
inventory_components | 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 params: css, html, url |
check_state_coverage | 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 params: css, url |
score_design_system | 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 params: css, html, url, pairs |
compare_token_sets | 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 colo params: before, after, before_url, after_url |
dtcg_to_css | 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 {va params: tokens*, format, prefix |
css_to_dtcg | 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 {g params: css* |
draft_brand_checklist | 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). E params: name*, audience, tone, constraints |
design_easing | 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, params: easing*, duration_ms, mass, stiffness, damping |
plan_durations | 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 rationa params: distance_px*, size, complexity, kind, allow_long |
audit_motion_css | 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-h params: css*, flashes_per_second, flash_area_percent |
plan_stagger | 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 pat params: count*, duration_ms, pattern, step_ms, budget_ms |
review_animation_principles | 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 sti params: description*, purpose |
lint_lottie_json | 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 params: json* |
lint_email_html | 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 params: html* |
check_email_preheader | 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 params: html, preheader, subject |
check_email_dark_mode | 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 i params: html* |
check_email_accessibility | 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 backgroun params: html* |
check_email_subject | 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, params: subject* |
calc_print_spec | 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 = thousand params: trim_width*, trim_height*, unit, bleed, safe, pages, caliper, caliper_unit, spine_extra_mm, binding |
calc_print_resolution | 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 params: width*, height*, unit, viewing_distance, distance_unit, pixels_w, pixels_h |
check_colour_mode | 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 co params: colors*, stock, smallest_text_pt |
convert_paper_size | 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 dif params: size, width, height, unit |
plan_imposition | 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 eve params: pages*, binding, signature, caliper_microns |
print_file_checklist | 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 an params: product, colour, finishes |
approx_print_colour | 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 params: value* |
logo_size_rules | 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 params: width*, height*, unit, letterform, kind, clearSpaceMultiple |
logo_contrast_variants | 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 reach params: colours*, logo, backgrounds |
brand_voice_consistency | 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 params: samples*, rules, bannedWords |
naming_check | 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 params: names*, existing, tld |
tagline_review | 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, params: taglines*, brand, cliches |
brand_architecture_planner | 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 a params: company, products* |
colour_palette_brief_check | 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-d params: palette*, brief |
review_microcopy | 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), em params: items* |
error_state_writer_template | 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 squa params: problem*, cause, fix, where, severity, dataSaved, canRetry, contact |
content_hierarchy_check | 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; params: text*, keyTerms, firstWords |
plain_language_check | 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 negat params: text*, targetGrade, jargon |
localisation_readiness | 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 params: strings*, languages, maxChars, expansion |
button_label_consistency | 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, sh params: labels*, groups |
notification_copy_check | 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 params: notifications*, channel |
nav_depth_check | 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, t params: tree*, maxDepth, maxBreadth, pages |
label_clarity_check | 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 params: labels* |
url_structure_review | 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 chara params: urls* |
taxonomy_overlap | 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 k params: tags, categories, terms |
tree_test_scorer | 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 ra params: results*, expectedFirstClicks |
sitemap_to_outline | 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 params: input*, format |
cognitive_load_check | 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 Authen params: content* |
check_reading_order | 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 land params: source* |
plan_focus_order | 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 e params: markup* |
check_keyboard_shortcuts | 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 modi params: shortcuts*, platform |
check_input_modality | 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 dra params: source* |
check_rtl_readiness | 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 params: source* |
check_font_coverage | 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 params: text*, fonts |
review_date_number_formats | 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, p params: text*, locales, currency |
plan_text_expansion | 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 exce params: strings*, languages, maxChars |
check_name_fields | 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, params: markup* |
check_cjk_line_breaking | 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 params: source* |
review_locale_picker | 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, params: locales* |
check_handoff_spec | 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, navigat params: spec* |
check_naming_conventions | 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 sepa params: names* |
plan_asset_exports | 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 s params: assets* |
plan_responsive_images | 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 fetchpri params: breakpoints*, dprs, sourceWidth, format, aspect, urlPattern, aboveFold, maxViewport, content |
audit_icon_set | 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), ico params: icons* |
check_svg_bloat | 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, params: svg* |
write_design_changelog | 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, c params: before*, after*, version, title |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.