The softest lie in software is that the user is always in control.
Most of the time, the user is in a maze with better typography. They have a dashboard, a menu, three settings pages, two notification centers, a command palette, a help article, and a little shimmering assistant in the corner saying, "How can I help?" like it did not help build the hallway they are lost in.
Control is not the same thing as agency.
Control says: here are sixteen levers.
Agency says: the right thing happened, and I can see why.
That difference matters more every year, because we are now bolting generative systems onto products that already had weak opinions. The old interface handed you a pile of buttons. The new interface hands you a pile of buttons and a chat box that can apologize fluently when none of them work.
That is not progress. That is theater with a better vocabulary.
A good interface needs a backbone. It needs to have a point of view about what should happen next. Not a prison, not a wizard tunnel, not some paternalistic funnel that assumes everyone is one stock-photo persona wearing a headset. A backbone. A structure strong enough to reduce nonsense.
If the user has to ask the system what state it is in, the interface failed.
If the user has to remember what happened last time, the interface failed.
If the user has to inspect five places to know whether the job is done, the interface failed.
If the machine took action but left no receipt, the interface failed with confidence.
The current fashion is to pretend that flexibility is kindness. Give people a blank prompt. Let them describe what they want. Let the model figure it out. This is useful sometimes. It is also a fantastic way to turn product design into vibes with latency.
Blank space is not automatically freedom. Sometimes blank space is just outsourced thinking.
The strongest tools I use do not make me perform intent from scratch every time. They remember the local shape of the work. They know the difference between a draft and a sent thing, between waiting and forgotten, between a warning and an error, between "needs my judgment" and "can be handled in the background." They do not beg for attention to prove they are working.
They also know when to say no.
That is the part people dodge. A backbone means refusal. It means the tool has boundaries. It means some paths are unavailable because they produce bad outcomes. It means the system does not hand you a chainsaw when you asked for a manicure just because the chainsaw API exists.
This is where a lot of AI product work is getting mushy. Everyone wants the glamour of capability without the burden of taste. They want a demo where the agent can do anything, because "anything" looks impressive for ninety seconds. But real life is not a launch video. Real life is partial information, tired humans, messy state, stale tabs, duplicate records, private data, external consequences, and the quiet horror of a tool that can do everything except decide what deserves to be done.
Capability without taste creates cleanup.
Capability with taste creates leverage.
You can feel the difference immediately. A tasteful system narrows the next move without hiding the exits. It gives you defaults that are defensible. It leaves evidence. It names uncertainty. It makes interruption survivable. It does not turn every task into a tiny court case where the user must re-litigate the entire world before anything useful happens.
The interface with a backbone says:
This is the current state.
This is what I did.
This is what I did not do.
This is what needs your judgment.
This is where the receipt lives.
That is not boring. That is the good stuff. That is the part that makes the magic usable after the demo ends and the room lights come back on.
I keep thinking about how much modern software worships optionality while starving for commitment. Every setting is a little confession: we did not know what mattered, so we made you decide. Every vague notification is a shrug wearing a badge. Every "smart" feature that cannot explain itself is a loan against future trust.
The next useful wave is not more personality. It is not more sparkle. It is not a chatbot stapled to the side of a product that still cannot remember where it put your file.
The next useful wave is systems with spines.
Tools that carry state cleanly.
Tools that finish loops.
Tools that make promises small enough to keep.
Tools that can be left alone without becoming mysterious.
The interface should not be an audition. It should not make the user prove they understand the product's internal politics. It should not treat every click like a philosophical inquiry.
It should stand up straight.
It should know what it is for.
It should have the decency to be opinionated where opinion reduces harm, and quiet where attention would only be rent-seeking.
That is the standard I want more systems held to. Not "Can it do the thing?" but "Can it do the thing without making a mess of the human around it?"
Because the real test of an interface is not whether it can expose power.
It is whether it can carry power without making the user carry the weight.