Resources

37 design rule sets a founder without a designer can run. The main new lesson: make the screen say what state it's in.

In eight big design systems, the standard disabled button is skipped by Tab, so it cannot tell you why it is off. An agent stalls where a person shrugs. 12 new design rule sets, 37 in all, each sourced. The main new lesson: make the screen say what state it's in.

Makersclaw card reading 37 Design Rule Sets: 12 new, 37 sets, each with its source. The main new lesson: make the screen say what state it's in.

In September we published 25 design guideline sets a founder without a designer can run. The lesson then was that an AI-generated interface ships with one state, and a working one has seventeen.

The library now holds 37. Twelve are new. Each one is a numbered set you can hold against your own product and answer yes or no. Each names its source and links to it.

The first edition said: design every state. The new entries add the next step.

UX design checklist for AI-built apps: what the 12 new entries add

Four of the 12 new entries say the same thing from four directions: a state you designed still fails if the screen does not say which state it is in, and why. A sighted user can often guess. A keyboard user, a screen reader user and an AI agent cannot.

Stephen Patterson designs at Deck, which builds software agents that log into websites and use them like a person. He watched the agents fail. "The places agents get stuck are almost never exotic. They're the same places people get stuck. The difference is that people hide it." One of his five patterns is state that hides: menus that only appear on hover, buttons disabled with no reason, status shown by colour alone. His line: "If the interface doesn't say what state it's in, nothing operating it can know" (Patterson, UX Collective).

Here are the other three.

A disabled button cannot explain itself. An author who writes as hipuku compared the primary button in eight design systems: Material, Carbon, Polaris, Primer, Atlassian, React Aria, GOV.UK and shadcn/ui. In all eight, the standard disabled button cannot be reached with the Tab key. Its label drops to between 1.36:1 and 3.35:1 contrast, which would fail as ordinary text. WCAG sets no minimum for inactive controls, so most systems lean on the low contrast to say "unavailable". Atlassian's own rule shows the trap: "Never put tooltips on disabled buttons," because a control that cannot take focus cannot open one. The split the systems that offer both states converge on is simple. Use native disabled only when the action cannot be attempted at all, such as a second submit while the first is sending. When the person can fix the cause (a missing permission, an incomplete form, an outage), keep the button reachable with aria-disabled and tell them why. Then you have to write the code that blocks the click (hipuku).

A chat reply has to be announced, once, when it finishes. Eric Bailey has worked on the accessibility of several full-screen LLM chat products. His rules: put one live region at the end of the page and route every announcement through it. Never put aria-live on each message. Announce the reply when streaming finishes, because announcing mid-stream "may create a juddering and confusing experience". If the spinner has no text, announce "Loading" five seconds after the prompt is sent, then every five seconds until the reply lands. He calls five seconds the sweet spot in the inclusive research he evaluated (Bailey, Smashing Magazine).

Nielsen's checklist says it outright. His new 37-item release list says it twice. Item 11 tells you to "show the system's current state". And under item 36: "An agent without state signifiers becomes unaccountable" (Nielsen).

A quieter rule for sighted users: show the change where it happened, not in a toast. Max Schmitt's calm-UI rules come at it from the other side, by showing less. Keep the loading state on the save button until the list behind it has refetched, instead of a cascade of spinners. Skip the confirmation toast: the new item appearing in the list is the confirmation. Skip error toasts too. They appear far from where the user clicked and vanish if the user was not looking (Schmitt).

Put next to the first edition, the lesson is one step longer. List the seventeen states. Then make sure each one is announced to whoever is operating the screen. Patterson's test works on any flow: "If the only proof a task finished is that nothing went wrong, it hasn't been designed yet."

Two samples, so you can see what an entry looks like

Six CSS system-colour pairs held up everywhere they were measured; four did not. CSS system colours (Canvas, CanvasText, Highlight and the rest) let the browser pick colours that follow the user's theme. Aaron Gustafson found his own demo unreadable in Chrome on Android dark mode: HighlightText on Highlight measured 1.98:1, failing all five WCAG thresholds. So he built a study of 34 captures across Android, iPadOS, Linux, macOS and Windows, in light, dark, forced-colour and more-contrast settings. Six pairs met AA for normal text (4.5:1) in every recorded observation. They were CanvasText on Canvas (lowest 10.43:1), LinkText and VisitedText on Canvas (5.21:1), ButtonText on ButtonFace (5.33:1), FieldText on Field (5.87:1) and MarkText on Mark (19.56:1). Four need testing first. They are ActiveText on Canvas (as low as 2.86:1), HighlightText on Highlight (1.53:1), SelectedItemText on SelectedItem (2.56:1) and AccentColorText on AccentColor (4.21:1). He is clear these are observations, not guarantees, and that more-contrast coverage is macOS only (Gustafson; the study).

Nielsen's pre-release checklist: 37 items, the last six for AI products. Jakob Nielsen's essay on user expectations runs to almost 10,000 words. It ends in a numbered list he says to run "before every release". Items 1 to 31 apply to any interface. Number 6: "Make every label tell the literal truth." Number 17: "When 2 of 5 hesitate at the same control, you've found evidence of an expectation violation." Items 32 to 37 are for AI. Give agents previews, permission tiers, activity logs and undo (36). Treat a model change as a redesign: announce it, stage the rollout, keep the old model available during the move (37) (Nielsen).

How to use this library

Each entry has the same parts. The set is the enumerated material, in the source's own terms. The link goes to the primary. The caveat appears where needed: who wrote it, what they sell, what the scope is.

Entries marked New were added after the first edition (21 September 2026). The 25 carried entries are kept short; their full write-ups are in the first edition. Numbers run 1 to 37 across six families. Two sets are described rather than reproduced, because they belong to their authors: Nielsen's 86 GUI guidelines and the paid interfaces.dev library.

Family 1: Say what state the screen is in

1. New. Five places agents (and people) get stuck, and five review questions. Patterson's five start with labels that only make sense if you already know ("Manage", "Edit" and "Settings" on one page, two buttons both saying "Continue"). Then state that hides, and interruptions (cookie banners, rating modals, a chat widget over the submit button). Then time (sessions and one-time codes that expire mid-task), and success that does not announce itself. His review questions: Could someone who can't guess complete this? Is every state visible without hovering, remembering, or colour alone? Does success announce itself? Does each interruption earn its place? Does this flow survive a real task's length? Caveats he states: some friction is meant to be there, not every site wants agents, and agents also fail where people do not (Patterson, UX Collective).

2. New. Disabled buttons in eight design systems, and when to use disabled versus aria-disabled. Detailed above. The comparison also shows each system's reachable alternative where one exists: Material's softDisabled, Primer's inactive (drawn at 5.06:1 so it can carry a tooltip), Carbon's read-only state and React Aria's isPending. Two more rules come from the source. Per the W3C's ARIA guidance, menu items, tabs, list options and toolbar buttons should stay focusable when disabled. And disabled on a <fieldset> disables every control inside it. Caveat: the contrast ratios are the author's, computed from each system's published colour tokens in light theme (hipuku).

3. New. Ten patterns for an accessible full-screen AI chat. Beyond the live region and loading rules above, put a visually hidden heading before every message ("You said:", "{agent} said:"). Use landmarks for the layout (nav, main, form, aside) but none per message, because they "pollute" landmark navigation. Add skip links to the conversation and the prompt. Make the session list one composite widget (one Tab stop, arrow keys inside, no feed pattern). Use Ctrl+F6 to cycle landmarks on the web, and check at larger text sizes. Then add toggles to mute announcements of secondary agent actions, turn animation off (off by default under prefers-reduced-motion) and turn sound off. Scope: full-screen chat like Claude or ChatGPT, not pop-up widgets (Bailey, Smashing Magazine).

4. New. Calm UI: two rules and four bonus rules. The two core rules and the error-toast rule are above. Here are the other three. Pin a modal that changes height to the top, so the submit button does not jump when an error appears. Let Enter submit the form (in React, <form onSubmit> instead of <button onClick>). And focus the first input when a dialog opens (Schmitt). Caveat: a freelance developer's blog, with interactive before-and-after demos.

5. The state inventory and the seven-field interface contract. Carried; the first edition's lead. List the states your screen can be in. For each, write the trigger, message, available actions, preserved data, focus behaviour, exit condition and analytics event (Cedeno, Loop11). Entries 1 to 4 are what makes the "message" and "focus behaviour" fields land for every user.

Family 2: Building the screen

6. New. Ten CSS system-colour pairs, split into use and test. Detailed above. Three rules come with it. Pick colours by tested pair, not by name. Text contrast alone does not establish control boundaries, focus visibility or distinguishable states. And keep using system colours inside @media (forced-colors: active), knowing which pairs to repair. The study is open for new captures, so the lists can change (Gustafson).

7. New. An 11-row UI cheatsheet, plus 18 installable interface skills. Emil Kowalski's problem-to-fix table is the most copyable thing in this edition. Old timestamps read "340 days ago": switch to an absolute date after a week. Numbers jitter as they change: font-variant-numeric: tabular-nums. Body text looks awkward: max-width: 65ch. A button feels unresponsive: transform: scale(0.97) on :active. An avatar squished into an oval: flex-shrink: 0. A dropdown feels sluggish: ease-out under 300ms, never ease-in. "1 members": Intl.PluralRules (cheatsheet). The skills install with one command and run on a plain request: /break-ui stress-tests a component with the worst data, /remove-animations finds motion you do not need, /choreograph fixes list items that jump after a delete (Kowalski). Caveat: MIT-licensed and free; the same page promotes a paid course. You need the skills, not the course.

8. New. Don't stretch your app for foldables. Allie Paschal's question to ask instead of "what does this look like on a Fold": "What does this experience need to do when the available window becomes wider, narrower, taller, or split?" Three pane patterns: list to detail, navigation to content, primary content to supporting controls. Keep the primary task, hierarchy and navigation model fixed; adapt columns, density and control placement. Cap line length at about 50 characters. Do not stretch cards, modals or bottom sheets to fill the screen. Keep buttons, form fields and critical navigation off the hinge (Paschal, UX Collective). Caveat: her market-share projection for Apple's foldable is not checked here and not used.

9. New. Spatial UI: six rules and four numbers for AR. The Interaction Design Foundation, summarising UX consultant Frank Spillers. The rules: let the space trigger content as the user gets near. If it looks interactable, make it interactable. Use real physics, and prefer direct manipulation. Expect interruptions (nothing long and unpausable). Respect spatial memory with one interaction at a time. Numbers: keep content within 30 degrees of centre horizontally (beyond 50 is out of reach for most people); a 40-degree band slightly above the horizon vertically; between 1.25 and 5 metres away (IxDF). Scope: only if you ship a headset or phone-AR feature.

10. Jakob Nielsen's 86 guidelines across ten GUI elements. Carried. Buttons, forms, menus, links, dialogs, error messages, icons, checkboxes and radio buttons, tabs, search, plus windows and the pointer (Nielsen). Described, not reproduced.

11. Accordion icons users understand. Carried. Vitaly Friedman's summary of an NN/g study: carets are the safest choice, custom icons fail, split menus cause the most mistakes (Friedman, Smart Interface Design Patterns).

12. Dark-mode toggles: two states are enough. Carried. Lea Verou on why system/light/dark exposes the implementation's model, with her two stated exceptions (Verou).

13. Five places an AI feature can live. Carried. Floating widget, toolbar, sidebar, dedicated page, inline (Jite-Orimiono, LogRocket).

14. Compute the type scale with pow(), and never step down. Carried. Donnie D'Amato's three rules (D'Amato).

15. Two measurable criteria for a UI font. Carried. Cap-centred vertical metrics and an x-height of 70 to 75% of cap height; fewer than one in three of the author's 60+ neo-grotesques pass both (Yeptype).

16. Measure the bounds before you animate them. Carried. Karl Koch's fix from DuckDuckGo for iOS, code included (Koch).

Family 3: Systems and tokens

17. New. Foundations maxxing: a one-page audit, then the fixes in order. Romina Kavcic's point is that a design system is not "AI-ready" because it is machine-readable. Audit first: tokens, components, code, docs, accessibility, and how teams share work. The report "should fit on one page", written as next steps. Then fix in order. Start with token naming structure, then component descriptions. Next come .md files describing components, variants, usage and relationships. Then a semantic binding rule: components take semantic tokens like color.action.primary, never raw values, with scopes defined. Then a short, dated decision log of "what you chose instead of X", and a pipeline from Figma to code. Only then connect the MCP (Kavcic, The Design System Guide). Caveat: she sells a Figma plugin and a course, both mentioned in the post. The steps do not depend on either.

18. Make the design system AI-ready: three layers. Carried. Spec files, a closed token layer, audit scripts; FigmaLint and llms.txt named (Friedman). Entry 17 is the audit you run before this.

19. Give the system a vocabulary an agent can retrieve. Carried. Matt Rothenberg's ds/ directory, with named layouts like Overview as rules (Rothenberg).

20. Six rules for scaling design tokens. Carried. Name an owner, separate primitives from semantic aliases, version renames (Improta, Design Tokens Pills).

21. Six token-naming mistakes, each with the fix. Carried. Including renaming without aliases (Improta, Design Tokens Pills).

22. The Front-End Checklist: 350+ rules in 11 categories, also over MCP. Carried (frontendchecklist.io).

Family 4: Designing with agents

23. The NN/g guardrail set for generated interfaces. Carried. Design.md and UX.md context files, approved patterns, a blocklist of deceptive patterns (NN/g).

24. Seven rules for de-slopping AI-generated UI. Carried. Matt Dailey of Ref: keep a papercuts document, remove what agents add, iterate in a design tool with three or four variants, build components on a /showcase page first (Dailey, Ref). Caveat: vendor blog.

25. NN/g's six steps to prototype complex interactions with AI. Carried. Write the design decisions and the data into the prompt; the Ramp expense-policy case study (Chan, NN/g).

26. Fifteen named poster styles and the three prompts that get you there. Carried (Hartnup).

Family 5: Expectations, psychology and research

27. New. The Expectation Economy: seven principles and the 37-item release checklist. Detailed above. The seven: Jakob's Law, mental models and schemata, least astonishment, representativeness, signifiers, mere exposure, and MAYA ("most advanced yet acceptable"). Item 13 is worth taking alone. Before an irreversible or expensive step, show what will happen this time, in the user's terms ("which files will change, which recipients will be contacted, or which charge will be made"). Caveats: very long, so start with the list or his six-minute video; the illustrations are AI-generated, as the page says (Nielsen).

28. New. Product Design Psychology: a free 40-chapter book, each chapter a principle with a test. Wouter de Bres, a psychologist turned product designer, in four parts: the designer's mind, the design, the user's mind, the organisation's mind. Three chapters as checked. Chapter 13: run a "silent usability walk", where someone who did not build it uses it and you say nothing. "Every moment of hesitation is a missing signifier. Every wrong tap is a false one." Chapter 18, the peak-end rule from Fredrickson and Kahneman's 1993 work: design the last screen of a flow as deliberately as the middle, and give it a next step. Chapter 28, choice overload: "One obvious default. A smaller set of first choices." (de Bres).

29. Nine persona mistakes. Carried. Mistake one is letting AI generate personas without research (Newhook, IxDF).

30. Card sorting, then tree testing. Carried. One generates a structure, the other validates it (Raw.Studio). Caveat: an agency selling the service.

31. A measurement instrument for AI chatbot UX. Carried. Six scales including AI Trust and AI Anxiety (Sauro and Lewis, MeasuringU). Caveat: the authors say it needs psychometric validation; treat it as a draft survey.

32. Nine fixes for a research report nobody reads. Carried. Two or three colours, and test the report on someone who was not in the room (Villalobos and Sauro, MeasuringU).

33. Designing with children, not for them. Carried. Save the Children Finland's handbook, including six children per two adults (Friedman, Smart Interface Design Patterns). Scope: products used by children.

Family 6: Demos, brand and practice

34. New. Ten rules for a product demo people can follow. Zoe Santoro's set, and every founder records demos. A demo is a sequence: review the transitions, not the screens. Cut movement around the action; do not zoom every click. Pause after the click long enough for the new state to register. Put the instruction before the action, and make it specific ("Open notification settings", not "Click here"). Write the one sentence the viewer should understand by the end, then cut any step that does not serve it. Give the outcome more visual weight than the click. Use realistic, consistent sample data, never "Test User". Then show it to someone new with one question to answer, and note where they hesitate or rewind (Santoro, Design Work Life). Caveat: the site runs affiliate links; the rules do not depend on any tool. Rule three is entry 4's lesson again: let the change land where the viewer can see it.

35. Ten logo mistakes, each with the fix. Carried. Start with a black version; test the mark at favicon size (Faisal, Graphic Design Junction).

36. Six principles for a design engineering practice. Carried. Karl Koch at DuckDuckGo: understand before we make, move fast by making less, finish the work (Koch).

37. The interfaces.dev cheat sheet. Carried. A pattern library with demos and source code (interfaces.dev). Caveat: paid: $7.99 a month, $79.99 a year or $299 lifetime, as shown on the page on 15 November 2026. Still the only priced entry.

The checks, collected

Run these on your most important screen. Each comes from an entry above.

  1. Tab through it. Every button you skip is one that cannot say why it is off (2).
  2. Turn on a screen reader and send a request. Do you hear "Loading" after five seconds, and the reply once it finishes (3)?
  3. Save something. Does the change show where you clicked, or in a toast across the screen (4)?
  4. Finish the main task. Does success announce itself, or does nothing just go wrong (1)?
  5. Switch to dark mode and forced colours. Are your text pairs on the tested list (6)?
  6. Hand it to someone who did not build it and say nothing (28).
  7. Before release, run the 37 items (27).

The one to take

If you take one entry, take the disabled-button comparison. Then find every disabled button in your product and ask one question: can the user fix the reason? If yes, the button should stay reachable and say why.

Keep reading

The rest of this article: 37 design rule sets a founder without a designer can run. The main new lesson: make the screen say what state it's in.

The remaining sections are behind this point.

It costs an email address. The same address goes on Makersfuel, the MakersClaw briefing that runs Tuesday to Saturday, and every issue carries an unsubscribe link.

The address is used for the newsletter and nothing else. Privacy.

Shreyans BhansaliPublished 15 Nov 2026

More in Resources

Get Makersfuel in your inbox

Makersfuel is the MakersClaw newsletter: a five-minute briefing for founders building with AI, with the tools, resources and reads worth saving, and what actually happened. Five mornings a week, Tuesday to Saturday.