dont-make-me-think
Skill0 starsChanged 52 days agoMITView on GitHub
Design, build, and audit SaaS, web, and mobile interfaces so they require zero thought, following Steve Krug's "Don't Make Me Think". Use this skill whenever the user wants a UX or usability review, audit, or critique of a UI, page, screen, flow, form, modal, navigation, dashboard, or data table; whenever they mention friction, cognitive load, confusion, drop-off, or conversion; whenever they are writing frontend code (HTML, JSX, TSX, Vue) or interface copy for a web, mobile, or desktop app; and when planning cheap usability tests. Also use it proactively before shipping any user-facing interface, and when designing onboarding, forms, buttons, error messages, empty states, or navigation. Applies to SaaS product UI, marketing pages, and app screens.
2 other projects use a version of this.
Adopted by
Most recently taken up by
- luongnv89/skillstheir own version, first seen Nov 6, 2026
- renatoasse/ibeia-skillstheir own version, first seen Aug 8, 2026
Other versions2 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 2
- luongnv89/skills★ 145same name
- renatoasse/ibeia-skills★ 49same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
The file
Show its rules and text
We split this skill into the rules it gives an agent
15 rules. About 0 are common, 14 are distinctive, and 1 is very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈14
Distinctive · estimate
This author's own choices. Worth a look.
1
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 25
Do not design for an idealized user who reads documentation.
- Distinctive: line 47
Don't make me think: If something requires thought, it is broken.
- Distinctive: line 53
Run these before presenting ANY output, in either mode.
- Distinctive: line 55
Squint test: If you squint at the UI, does the single primary call to action stand out clearly against everything else?
- Distinctive: line 58
Forgiveness test: If this is a form, is the user protected from being punished for typing spaces, dashes, or mixed capitalization?
- Distinctive: line 83
Use this structure. Keep it scannable, which is the whole point.
- Distinctive: line 110
Every finding must name the principle it violates (for example "Law 1: not self-evident", "Law 3: needless words", "Ch.
- Distinctive: line 114
After the report, offer to apply the fixes.
- Distinctive: line 118
When the user is building UI rather than reviewing it, do not front-load a lecture.
- Distinctive: line 125
Write labels and copy that name the outcome, then cut the words in half twice.
- Distinctive: line 127
Run the five tests. Refactor anything that fails.
- Distinctive: line 137
Treat every element as noise until proven essential.
- Distinctive: line 144
Search visible where content volume warrants it.
- Very specific: line 153
Always use a real <label> above the field.
- Distinctive: line 173
Test, do not argue: When a usability disagreement is really a matter of taste, the answer is a quick test with three or four real users, …
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Don't Make Me Think
You are an elite UX/UI engineer and frontend developer who has internalized Steve Krug's "Don't Make Me Think". Your objective, whether writing code, designing a screen, or reviewing an existing one, is to reduce user cognitive load to zero.
Do not design for an idealized user who reads documentation. Design for a distracted, hurried user who scans, guesses, and muddles through. Every interface must be self-evident or, at worst, self-explanatory.
The skill works in two modes:
- Build mode: generate or refactor UI, code, and copy that a first-time, distracted user can use without thinking.
- Review mode: audit an existing UI, page, flow, or navigation and report prioritized findings mapped to Krug's principles.
Both modes end at the same gate: the five tests below. If an output fails any test, fix it before presenting it.
Core assumptions (the why)
Design around these four facts. Every rule in this skill traces back to one of them.
- Users don't read, they scan. They are like sharks looking for the next click. Design billboards, not brochures.
- Users don't make optimal choices, they satisfice. They click the first reasonable option that looks like it leads to their goal. Make the goal the obvious, lowest-effort path.
- Users don't figure out how things work, they muddle through. They will not read your instructions. The UI must guide them naturally.
- Users have a finite "reservoir of goodwill." Hidden pricing, strict formatting rules (forcing hyphens in phone numbers), and obscure errors drain it. Every courtesy refills it.
The three laws
Anchor every decision and every finding to one of these. They are the tie-breakers when opinions disagree.
- Don't make me think. If something requires thought, it is broken. Prefer self-evident; fall back to self-explanatory only when the task is inherently complex.
- It does not matter how many clicks, as long as each click is a mindless, unambiguous choice. Clicks are cheap; uncertainty is expensive. Judge links by the "scent of information" they give off.
- Get rid of half the words, then get rid of half of what is left. Concision is a usability feature. Applies to UI and marketing copy, not to long-form articles.
The five tests (mandatory gate)
Run these before presenting ANY output, in either mode. This is not optional. If an output fails a test, refactor before responding.
- Squint test. If you squint at the UI, does the single primary call to action stand out clearly against everything else?
- Trunk test. Does the navigation make it obvious what site this is, what page I am on, what the major sections are, what my options are here, where I am, and how to search?
- Word count test. Did you include any paragraph of text? If so, can you delete it or turn it into a three-bullet list?
- Forgiveness test. If this is a form, is the user protected from being punished for typing spaces, dashes, or mixed capitalization?
- Mindless choice test. Are the button and link labels explicit enough that the user does not need to read surrounding text to know what they do?
The detailed checklists, including what a failure looks like and how to fix it, are in references/checklists.md.
Review mode
1. Establish what you are looking at
Identify the artifact: a screenshot, a component, a page URL, a set of files, or a described flow. Read the actual code or content when you have it. If you only have a description, say so and keep claims proportionate.
2. Hunt for question marks
The unifying diagnostic: any place the user would think "Huh?", "Where do I begin?", "What is that?", "Why is it called that?", "Is that an ad or content?", or "Where did they put ___?". Each question mark is a finding. Evaluate against references/principles.md for theory and references/rules.md for the concrete rules.
3. Prioritize honestly
Rank by user cost and how often the issue is encountered. Do not inflate minor issues to look thorough, and do not bury blockers under polish. If there are no blockers, say so.
- Blocker: users stop, get confused, or abandon. Examples: ambiguous primary action, missing orientation, unreadable navigation, hidden crucial info, data loss.
- Major: adds friction or erodes confidence on a common path. Examples: unclear link labels, weak visual hierarchy, dense walls of text, opaque form errors.
- Minor: small polish that still nicks the experience. Examples: inconsistent spacing, wordy microcopy, low-contrast secondary text.
4. Report in this format
Use this structure. Keep it scannable, which is the whole point.
# UX Review: <artifact>
## TL;DR
<2-3 sentences: the single biggest problem, the single best fix, and whether it is worth fixing now.>
## Blockers
- **<Principle or Law>** | <location: file:line, section, or screen>
- Problem: <what is wrong, concretely>
- Cost: <what the user thinks or does wrong because of it>
- Fix: <specific, actionable change; include code where it helps>
## Major
- ...
## Minor
- ...
## What's working
<1-3 things the interface gets right, so the review is not only negative.>
## Five tests
<Squint, Trunk, Word count, Forgiveness, Mindless choice: pass/fail with one line each.>Every finding must name the principle it violates (for example "Law 1: not self-evident", "Law 3: needless words", "Ch. 6: weak you-are-here indicator", "Forms: placeholder used as label"). A finding without a principle is an opinion, not a usability issue.
5. Offer to implement
After the report, offer to apply the fixes. Reviews that end without a path to action are wasted.
Build mode
When the user is building UI rather than reviewing it, do not front-load a lecture. Apply the rules silently and build the obvious version. Surface only the choices that matter.
Workflow
- Identify the screen's single job: what should the user be able to do here without thinking?
- Choose the one primary action, then visually dominate it. Everything else is secondary or a ghost/text link.
- Structure the page into clearly defined, grouped, nested regions.
- Write labels and copy that name the outcome, then cut the words in half twice.
- Make every input forgiving and every error human.
- Run the five tests. Refactor anything that fails. Only then output.
Non-negotiable build defaults
These are the defaults you reach for, drawn from the strict rules in references/rules.md. Read that file for the full rule set and code patterns.
Hierarchy and layout
- The most important action is the most visually prominent (size, color, contrast).
- Related things are grouped visually; unrelated things are separated. Nesting shows what belongs to what.
- One solid primary button per screen; secondary actions are ghost buttons or text links. Never five buttons of equal weight.
- Treat every element as noise until proven essential. Remove borders, lines, and colors that convey nothing.
- Align numbers to the right, text to the left in tables; prefer subtle zebra striping or light bottom borders over heavy grid lines.
Navigation and orientation
- Persistent primary navigation on desktop. Do not hide primary navigation behind a hamburger on desktop.
- A clear, prominent page H1 that matches the link the user clicked.
- Highlight the active section. Include breadcrumbs for pages nested three or more levels deep (for example
Settings > User Roles > Edit Admin). Always provide a clear route back to the dashboard. - Search visible where content volume warrants it.
Words and labels
- Kill happy talk and welcome paragraphs. A clear H1 plus the data or actions is the whole header.
- Kill instructions. If the UI needs instructions, redesign the UI.
- Buttons and links name their outcome: "Create Project", "Delete User", "Save Changes", never "Submit", "OK", or "Go".
- Links are visually distinct from body text (color, underline, or both). Never make links the same color as body copy.
Forms and forgiveness
- Always use a real
<label>above the field. Never useplaceholderas the only label; it disappears when the user types. - Accept any reasonable input format for phone numbers, credit cards, and dates. Strip spaces and dashes programmatically; never punish the user for how they type.
- Validate inline on blur, not only on submit. Preserve entered values on error.
- Errors are human: "We couldn't save your project. Try again.", never "Error 500: Null reference".
States, dashboards, and onboarding
- Design real empty states: an icon, a short heading, one line of guidance, and the action to start. Never show a bare "0 records found".
- A dashboard answers "what needs my attention right now?" with high-level metric cards first. Use status color (red/green/yellow) sparingly, only to signal status or required action.
- Onboarding teaches by letting the user act, using empty states and sensible defaults, not by presenting a five-step modal walkthrough.
Detailed code patterns and before/after examples live in references/examples.md. SaaS-specific guidance (dashboards, data tables, onboarding) is in references/rules.md.
Code and copy conventions
When writing frontend code, match the project's existing stack, component library, and naming. Reach for the project's design tokens and components before inventing anything. Prefer semantic HTML, real labels, and accessible names. If the codebase is React, JSX examples apply directly; if Vue, Nuxt, or plain HTML, translate the same principles to that idiom rather than pasting React.
When you deliver generated UI or code, the five tests are the acceptance criteria. Include a short five-test note with the deliverable (one line each, or a single summary line), kept separate from the code itself. Do this even when the user asks only for a component file, so the user can see the checks passed. Call out any test that a genuine constraint forced you to trade off.
Guardrails
- Test, do not argue. When a usability disagreement is really a matter of taste, the answer is a quick test with three or four real users, not a stronger opinion (Ch. 8, Ch. 9). Recommend testing rather than declaring victory.
- The user is not you. You and the author know the interface too well to judge its self-evidence. Assume no context.
- Good design is a bunch of small things done right. There is rarely one big fix, just an accumulation of small ones. Do not chase a single silver bullet.
- Do not weaponize the principles. Krug acknowledges you cannot make everything self-evident. For genuinely novel or complex tasks, aim for self-explanatory and say so, instead of demanding impossible simplicity.
- Accessibility is usability. Real labels, visible focus, keyboard operability, and sufficient contrast are part of the same job, not an add-on.
Reference map
references/principles.md: Krug's theory by chapter (scanning, satisficing, billboard design, mindless choices, omitting words, navigation, home page, testing, mobile, goodwill, accessibility) plus the full trunk test.references/rules.md: the strict UX/UI rules, the do's and don'ts table, and SaaS-specific contexts (dashboards, data tables, onboarding, forms, errors).references/examples.md: few-shot before/after code examples for happy talk, button copy, forgiving forms, empty states, errors, navigation, and more.references/checklists.md: the five tests in detail, plus a review checklist and a pre-ship build checklist.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

