Design your software for disappearance

Most of the software that truly moves the world doesn’t demand our attention: It quietly removes friction and gets out of the way. You only notice it when it’s broken. That’s not a bug in the business model; it’s a feature. In fact, “unnoticed but indispensable” is the highest customer-satisfaction score you can get.

Consider these categories that already figured this out.

The log-in that isn’t a task anymore

Password managers, once you build the habit, fade into the background. They fill the box before you even remember there was a box. Single sign-on (SSO) systems go a step further and make logging in to everything feel like one action instead of 17 small, annoying ones. And passkeys get rid of passwords entirely. The pattern is consistent: Tools that turn a chore into a non-event ultimately win.

It’s tempting to treat authentication like a “moment”: a page, a button, a ritual. The better approach is to treat it like plumbing. You notice good plumbing by its absence. Otherwise, you just enjoy the hot shower.

Invisible infrastructure already won the internet

Some technologies graduate from “choice” to “ambient.” Transport layer security (TLS) and HTTPS used to be optional. Now they’re table stakes, largely thanks to Let’s Encrypt making it approachable. Your browser nudges everyone toward secure defaults and the ecosystem complies. We don’t “do” TLS; we benefit from it.

This wasn’t always so seamless. In Windows’ early days, you literally had to install a Winsock stack just to speak TCP/IP. Today, the network stack is simply present, like oxygen. Progress in software often looks like this: The thing we once had to fiddle with becomes the thing we don’t think about anymore.

AI’s next act: not a chat box

Chatbots are neat, but they aren’t the end state of AI. They’re a first draft, like when we used to watch early web pages load images line by line. The real value emerges when intelligent assistance is in the room where work already happens, and it becomes part of the workflow.

• In a CRM, the note writes itself while you talk and is already tagged correctly when you hang up.
• In design tools, the spec is updated everywhere when you change a component once.
• In code review, a suggestion appears inline with a one-click fix, not in a separate AI tab that hijacks your focus.

This is the same story as passwords, SSO, and HTTPS: The win comes from disappearing the steps, not adding a new surface area for attention.

(The funny thing is, most of the work of making AI invisible is just plain old engineering. Yes, there’s lots of AI engineering to make the bots work at all. But plugging them into things in a way that works, that’s the part we’re really behind on.)

BORING ON PURPOSE IS A STRATEGY

At my company we talk about being boring in a specific way: Security and connectivity should feel like electricity. You flip the switch, the lights come on, and nobody argues about the generator or the continent-wide high-voltage distribution network. Being invisible is not the same as being trivial; it’s the reward for sweating details users never see.

Here are five design principles for making software people won’t notice

1. Make the default the decision.

Someone once told me the golden rule of user interface design: If there’s a popup with two options, imagine one of them is “work” and the other one is “don’t work.” Then make “work” the default and delete the popup.

Most users will never visit settings. If the secure, performant, accessible path is the default, adoption happens for free.

2. Budget for latency like it’s a feature.

Under ~100ms, interactions feel instantaneous. Over ~1s, they feel like work. Invisible software feels fast because it never gives the user time to switch contexts. Cache, prefetch, and defer like your product’s life depends on it. Because it does!

3. Automate the paperwork, keep the signatures.

Autofill, SSO, and passkeys are all versions of the same idea: The system should carry the burden. Let humans make approvals and set intent; let machines do the form filling and compliance trail.

4. Progressive disclosure beats feature sprawl.

Hide power tools until they’re needed. The user who needs advanced controls will find them; the one who doesn’t should never meet them. UIs that start simple and get deep on demand feel “light” and earn trust.

5. Fail quietly, recover loudly.

When background systems hiccup, self-heal first. If you must involve the user, say exactly what to do in one step and show you’ve already done the other three. Invisible products don’t turn every exception into a ticket.

THE BUSINESS CASE FOR BEING FORGETTABLE

“Unobtrusive” can sound like “unmonetizable,” but it’s the opposite. Products that vanish into the workflow produce fewer support tickets, shorter onboarding, and more expansion inside organizations. They spread by word-of-mouth because they don’t create new habits; they remove old pain. You don’t need a big campaign to sell relief.

The tricky part is cultural, not technical. Teams must be okay shipping value that isn’t screenshot-worthy. That means investing in the edges: reliability, identity, zero-touch setup, and instant rollback-so customers never have to learn those words.

A SIMPLE TEST

If turning your product off causes immediate, confused swearing from the people who didn’t even know they depended on it, congratulations: you’ve built something great. Now make it a little faster and a little quieter, and do that every quarter.

Because the best compliment your software will ever get is silence.

Avery Pennarun is CEO and cofounder at Tailscale.

View the full article