The 15 Laws of Proper UI / UX Design

I could barely contain myself...

I stared at the checkout screen of a multi-million dollar e-commerce platform and wanted to throw my laptop out the window. The button to actually pay was hidden behind a carousel of 'recommended products' that kept auto-scrolling as an upsell/cross-sell module in the cart. For the better part of two decades, I have torn apart software interfaces to see why people abandon carts or cancel subscriptions. The answer usually comes down to a crime against basic human psychology. We call these UX principles. Really, they are survival rules for the digital wilderness. Let's break down the fifteen laws you ignore at your own peril.

Stop Trying to Be Clever (Clarity)

Eliminating ambiguity is the absolute core of good design. If a user has to guess what a button does, you failed. An audit I ran last year revealed an enterprise app where the save icon was a stylized geometric bird. Nobody knew what it meant. Just write the word on the button.

You Are Not a Unique Snowflake (Jakob’s Law)

Jakob’s Law hurts the ego of every hotshot designer. Your users spend most of their time on other websites. They expect your digital real estate to work similarly to the rest of the web. Do not reinvent the wheel. Put the logo in the top left. Forcing people to learn a new navigation system is a quick way to lose money.

The Cheesecake Factory Problem (Hick’s Law)

More options and complexities mean longer decision times, according to Hick’s Law. Give someone a menu the size of a phone book, and panic sets in. Most folks will just order the chicken tenders. Narrow the choices down to save everyone's sanity.

Don't Make Me Hunt (Fitts’s Law)

Fitts’s Law is brutal physics. The longer it takes to move to a target, and the smaller that target is, the higher the error rate. Make the "Buy" button massive. Placing it exactly where a thumb naturally rests on a screen prevents costly misclicks.

The 400-Millisecond Rule (Doherty Threshold)

Productivity soars when a system responds faster than 400ms. That is the Doherty Threshold in action. Neither the human nor the computer should ever have to wait. I remember testing a banking portal that lagged just enough to make frustrated people click "Transfer" twice. Chaos ensued instantly. Keep the feedback loop tighter than a blink.

The Final Sprint (Goal-Gradient Hypothesis)

Local coffee shops hand out punch cards with two free stamps already on them for a reason. The Goal-Gradient Hypothesis proves that the closer people are to completing a task, the faster they work toward completion. Show users the finish line early. They will sprint the rest of the way.

Get Out of the Way (Efficiency)

Anticipating needs helps people work smarter and faster. Stop making users do the heavy lifting. Pre-fill those tedious forms automatically. Remembering passwords is another basic courtesy that speeds up the entire workflow.

Cut the Fat (Occam’s Razor)

Old philosophical concepts hold up perfectly in software. Occam’s Razor proves that the simplest solution is almost always the best solution. I sat in a board meeting once where executives debated a seven-step onboarding sequence for a flashlight app. My fix was literally one giant button.

The Mighty 20 Percent (Pareto Principle)

Vilfredo Pareto knew exactly what he was talking about. The famous 80/20 rule states that 80% of consequences come from 20% of the causes. In software, users spend the vast majority of their time on a tiny fraction of your features. Find out what those core functions are immediately. Polish them until they gleam.

Time is a Gas (Parkinson’s Law)

Tasks will always expand to fill the time available for their completion. Parkinson’s Law applies to users just as much as lazy employees. Give a person an hour to set up a profile, and they will take an hour. A ticking five-minute progress bar changes that behavior entirely.

You Cannot Delete the Hard Stuff (Tesler’s Law)

Every system has a certain amount of complexity that cannot be removed, according to Tesler’s Law. Someone has to deal with the mess. Making things stupidly simple for the end user means your developers must eat that complexity in the backend code. Pay the engineers to suffer so the customer does not have to.

Strict Output, Forgiving Input (Robustness Principle)

Being conservative in what you send and liberal in what you accept defines the Robustness Principle. Stop yelling at customers with red error text. If someone types their phone number with dashes, periods, or emojis, swallow your pride and accept the data. Fixing it on your own servers is your job.

Neighbors Talk (Proximity)

Items placed close together are naturally perceived as more related than things spaced far apart. Proximity matters immensely. Shoving the "Delete Account" button miles away from the "Update Profile" link is just common sense. A massive accidental purge of user data in 2014 taught me that lesson the hard way.

Fences Make Good Neighbors (Common Region)

Enclosed boundaries manipulate the brain. Elements within the same area are inherently perceived as related. Throw a subtle gray box around a pricing tier. Suddenly, random text strings look like a cohesive premium package.

Birds of a Feather (Similarity)

Shared characteristics make UI components look like a family. If things look the same, we assume they do similar things. Never color your "Cancel Order" button the exact same shade of bright green as your "Checkout" button. Angry emails will flood your inbox within the hour.

Building digital tools requires zero art. It demands the ruthless removal of friction. Next time you draft a form or design a checkout flow, ask yourself if you are making someone pause to think. Rip it down to the studs if the answer is yes.