Every principle, free to read.

The average person can hold only about seven (plus or minus two) items in working memory at once. The practical takeaway isn't a hard limit on menu length — it's chunking: group related information into a few meaningful units so the mind can hold and process it comfortably.

Elements placed close together are perceived as a group, even without borders, boxes, or shared colour. Spacing alone tells users what belongs with what — which is why a label sits tight to its input and unrelated sections get breathing room. Get proximity wrong and a form feels like confetti; get it right and structure appears for free.

When several similar things sit together, the one that stands out is the one people notice and remember. This 'isolation effect' is why a single high-contrast primary button among ghost buttons gets clicked, and why a 'Recommended' pricing tier draws the eye — but it also means if everything shouts, nothing is remembered.

People remember the first and last items in a series best, and the middle worst. That U-shaped curve — primacy at the start, recency at the end — is why the most important navigation items belong at the two ends of a menu, and why the last thing a flow says lingers longest.

Elements that share a visible boundary — a card, a panel, a background tint — are perceived as one group, even overriding proximity. Drawing a region around things is the strongest, cheapest way to say "these belong together."

Elements that look alike — same color, shape, or size — are perceived as related and interchangeable, no matter where they sit. Make all links look like links and all buttons look like buttons, and users learn your interface once instead of screen by screen.

Elements visually connected — by a line, a shared bar, a touching edge — are perceived as more related than elements merely near or similar. A literal connector is the strongest grouping signal of all, which is why steppers and flows draw the line.

People perceive ambiguous or complex images in the simplest form possible, because simple takes less cognitive effort. Interfaces that resolve into a few clean shapes feel effortless; ones that don't, feel "busy" before a single word is read.

Given fragments, the mind completes the whole: we see a full circle in a dashed outline and a panda in a few black patches. Interfaces exploit this to say more with less ink — and to hint that there's more content beyond the edge.

The eye instantly splits any scene into a figure (the thing to attend) and ground (the backdrop). Interfaces steer this with contrast, blur, shadow and dimming — a modal works because everything behind it visibly becomes "ground."

Elements that move together are perceived as belonging together. Motion is the strongest grouping cue we have — which is why a menu whose items slide in as one feels like one object, and why scattered, unsynchronised animation feels broken.

The eye follows lines and curves along their smoothest path, and elements arranged on a continuous line are perceived as related. Rows, columns and aligned edges are invisible rails that carry attention through a layout.

Grouping information into small meaningful units lets people hold and scan far more than a raw stream allows. A 16-digit card number is impossible; four groups of four is easy. Chunk content, numbers and forms, and comprehension jumps.

Users can hold only a few items in mind for a few seconds while acting. Any design that makes people remember information from one screen to use on another — codes, prices, option names — is spending their scarcest resource.

People attend only to what seems relevant to their goal and filter out the rest — famously ignoring anything shaped like an ad (banner blindness). Where you put a message matters more than how loud it is.

The total mental effort a task demands. Some load is intrinsic to the task; the rest — decoding layout, parsing jargon, hunting for buttons — is extraneous, and every unit of it comes out of the user's budget for the actual goal.

The time to acquire a target is a function of the distance to and the size of the target. Bigger, closer targets are faster and easier to hit — which is why primary actions should be large and within easy reach, and why tiny close-together tap targets cause mistaps.

The time it takes to make a decision increases with the number and complexity of choices — logarithmically, not linearly. Every option you add to a menu, a form, or an onboarding step taxes the user's decision time, which is why great products ruthlessly trim or stage their choices.

Productivity soars when a system responds in under ~400ms, because neither the person nor the computer is left waiting on the other. Above that threshold attention drifts, the flow of work breaks, and the interface starts to feel sluggish — which is why fast perceived response time is one of the highest-leverage things you can design for.

Every process has a certain amount of complexity that cannot be removed — it can only be moved. The 'law of conservation of complexity' asks who absorbs it: the user or the designer/system. Good products take on the hard, fiddly work internally so the person is left with the simplest possible experience.

Skeuomorphism is designing digital things to resemble their real-world ancestors so people already know how to use them. The desktop, folders, the trash can, the save icon — these metaphors were training wheels that taught a generation to use computers. Even after 'flat' design stripped the textures away, the metaphors (and the muscle memory) remain, which is why a floppy disk still means 'save' to people who've never held one.

An affordance is what an object lets you do (a button affords pressing); a signifier is the signal that tells you the affordance is there (the button looks pressable). Users don't read manuals — they act on what a control appears to offer. When the signifier is missing or misleading, you get confusion; when it's clear, the interface explains itself.

Users act on a compressed internal story of how your system works — built from every other system they've used. When the interface matches the model, it feels intuitive; when it fights the model, every click is a small betrayal.

Users spend most of their time on other sites and apps, so they expect yours to work the same way as all the ones they already know. Meeting those learned conventions lets people transfer existing skills to your product; breaking them for novelty's sake imposes a 'relearning tax' that usually costs more than the originality is worth.

When two designs solve the problem equally well, choose the simpler one. Every extra element, option, and flourish has a cost — it competes for attention, adds cognitive load, and gives one more thing to misread or maintain. Good interfaces are ruthless about removing anything that isn't earning its place, so the essential stands out instead of drowning in noise.

People judge an experience mostly by how it felt at its most intense moment (the peak) and at its end — not by the average of every moment. A flow can have friction in the middle and still be remembered fondly if it peaks well and ends on a high, which is why celebratory success states and graceful endings matter more than they seem.

People perceive good-looking designs as easier to use — and they'll forgive minor usability problems in something that looks polished. Aesthetics build a first impression of trust and competence that carries real usability weight. The flip side: a beautiful interface can mask real problems in testing, because users blame themselves rather than the pretty design.

Motivation accelerates as people get closer to a goal — and giving an honest head start (pre-crediting progress they've genuinely already made) makes them likelier to finish. Progress you can see is fuel; progress from zero is friction.

Unfinished tasks occupy memory far more than finished ones — an open loop nags until it's closed. Checklists, drafts and "pick up where you left off" all run on the itch of incompleteness.

Roughly 80% of effects come from 20% of causes: most users touch a small fraction of features, most revenue comes from a few flows. Find your vital 20% and spend your design effort there — the long tail can live in menus.

Work expands to fill the time available for its completion — and tasks balloon to fill whatever room the interface gives them. Constraints, defaults and autofill shrink the container so the task shrinks with it.

The state of full, energised immersion in a task — reached when challenge matches skill, goals are clear, and feedback is instant. Interfaces that interrupt, lag or confuse keep breaking the state that makes work (and play) feel effortless.

Users never read manuals — they start doing immediately, even when reading first would save time (that's the paradox). Design must teach inside the task: onboarding by doing, safe defaults, and recovery when the leap goes wrong.

Text has to stand out enough from its background to be readable — for everyone, including people with low vision. The WCAG standard puts a number on it: normal text needs a contrast ratio of at least 4.5:1 (large text 3:1). Low contrast is the single most common accessibility failure on the web, and the fix costs nothing but a colour value — you just have to check the ratio instead of trusting your eye.

Good type is about even space, not equal space. Kerning adjusts the gaps between specific letter pairs so the word reads as one balanced shape — because some pairs (AV, WA, To) leave awkward holes or collisions at equal spacing. Your eye notices when the rhythm is off even if you can't name why, which is why sloppy spacing makes otherwise-fine design feel amateur.

Be liberal in what you accept, conservative in what you send. Accept every reasonable way a human might type a date, phone or name — then store and display one clean canonical form. Rejecting valid effort on a technicality is a design bug.

The system should always keep users informed about what's going on, through appropriate feedback within reasonable time. Nielsen's first heuristic: pressed buttons acknowledge, uploads show progress, and nothing important happens silently — because silence reads as broken.

Better than good error messages is a design that prevents problems from occurring in the first place: constrain inputs to valid options, separate destructive actions from safe ones, confirm the irreversible, and make risky states visible before the mistake happens.

Nielsen's H2: the system should speak the users' language — words, phrases and concepts familiar to them — and follow real-world conventions, making information appear in a natural, logical order. Every internal code, schema name or engineering unit that leaks into the UI makes the user do the translation the software should have done.

Nielsen's H3: users often perform actions by mistake and need a clearly marked emergency exit — undo, redo, cancel, back — to leave an unwanted state without an extended dialogue. Power without a reverse gear is a trap; every irreversible path in your UI is a place users learn to fear.

Nielsen's H4: users should never have to wonder whether different words, situations or actions mean the same thing. Follow platform and industry conventions (external consistency) and your own established patterns (internal consistency) — every deviation makes users re-learn something they already paid to know.

Nielsen's H6: minimise memory load by making objects, actions and options visible. Recognising something you see is far easier than recalling it from nothing — so show choices, don't demand codes; surface history, don't require re-entry; and never make users remember information from one screen to use on another.

Nielsen's H7: accelerators — unseen by the novice — speed up interaction for the expert, so the system serves both. Shortcuts, bulk actions, saved templates and personalised defaults let frequent users fly, while the guided path remains for newcomers. Friction multiplied by frequency is where products quietly die.

Nielsen's H8: dialogues should not contain information that is irrelevant or rarely needed — every extra unit of information competes with the relevant ones and diminishes their visibility. This isn't about white minimalism as a style; it's signal-to-noise engineering. Ask of every element: what question does this answer, and does anyone here have that question?

Nielsen's H9: error messages should be expressed in plain language (no error codes alone), precisely indicate the problem, and constructively suggest a solution. Recognise → diagnose → recover: the user must learn WHAT happened, WHY, and WHAT TO DO NEXT — with their work intact. An error state is a fork in trust: handled well it builds it, handled with 'Something went wrong' it burns it.

Nielsen's H10: the best systems need no explanation, but when help is needed it must be easy to search, focused on the user's task, list concrete steps, and stay short. Help that lives where the confusion happens beats any manual; and wrong or stale documentation is worse than none, because users trust it straight into bugs.

A design that makes it very easy to get into a situation and deliberately hard to get out — one-tap subscribe, phone-call cancel. The exit must cost roughly what the entrance did; engineered exit friction converts users into hostages, not customers.

Wording the opt-out so declining feels shameful — "No thanks, I hate saving money." It weaponises self-image against the user's actual choice. Ethical persuasion sells the YES; confirmshaming taxes the NO.

Revealing mandatory fees only after the user has invested effort — drip pricing. The advertised number wins the comparison; the real number appears once sunk-cost makes abandoning feel expensive. Total cost belongs where the decision happens.

Items, add-ons, insurance or donations that join the cart without the user's explicit action — usually via a pre-ticked box or an opt-out buried in the summary. Consent is forged by a default. India's CCPA Guidelines (2023) name 'basket sneaking' outright: anything that costs money enters the basket only by the user's own hand.

A free trial or discounted period that silently converts into recurring charges — card collected up front, no reminder before billing, cancellation hidden or delayed. The CCPA (2023) calls it the 'subscription trap'. Continuity itself isn't dark; the darkness is monetising the user's forgetting instead of their consent.

Repeated, unwanted interruptions — rating begs, notification re-prompts, upsell banners — that continue after the user has said no, until surrender reads as consent. Named in the CCPA Guidelines (2023). The tell: a 'no' that doesn't persist. Asking is fine; asking AGAIN after an answer is attrition, not persuasion.

The user sets out to do one thing and something different happens: a download button that installs something else, a close button that opens an ad, an advertised price that never exists at booking. Named in the CCPA (2023). The pattern weaponises learned affordances — the more universal the control, the more profitable its hijack.

Ads styled to be indistinguishable from content, navigation or search results, so clicks meant for the product go to the advertiser. Named in the CCPA (2023). Advertising is legitimate; DISGUISE is the pattern — the ad rents the user's trust in a format it didn't earn. The fix is almost embarrassingly simple: label it, visibly.

Invented stock counts, countdown timers that reset, and fabricated 'people viewing now' numbers that manufacture panic to rush decisions. 'False urgency' leads the CCPA's 2023 list. Real scarcity is information; the LIE is the pattern — and the tell is falsifiability: does the timer expire, does the count come from inventory, do the viewers exist?