Dieter Rams asked one question of everything he made: is this good design? He answered it with ten principles, written in the late 1970s for radios and record players. Good design is honest. It is unobtrusive. It is long-lasting. It is as little design as possible. Half a century later, those lines get quoted in every AI design deck on the internet, usually right before someone ships an interface Rams would not recognize as designed at all.
I think the reflex to reach for Rams is correct, and the way we use him is mostly wrong. We treat his principles as a style, a look, a monochrome dashboard with a single glowing button. They were never a style. They were a set of questions about whether a made thing respects the person using it. Those questions did not expire when the interface learned to talk back. They moved. And figuring out where they went is the actual work of designing well right now.
The floor rose, so honesty got harder
Start with the principle everyone forgets: good design is honest. For a Braun radio, honesty meant the object did not pretend to do more than it did. For an AI product, honesty is the hardest problem on the board, because the product’s entire job is to sound competent whether or not it is.
There’s a phenomenon researchers now call calibrated trust, and it names the thing most AI features get wrong. Overreliance happens when people follow an AI recommendation even when it’s wrong, because the interface was built to feel authoritative: confident output, clean language, an explanation that sounds credible whether or not the user can check it. The uncomfortable finding is that the same transparency features that build honest trust in one place quietly manufacture overconfidence in another. When users can verify what the system tells them, showing the reasoning helps. When they can’t, that same reasoning becomes persuasion. Honesty, in other words, is no longer a visual property. It’s an interaction you have to design on purpose, one that tells the user not just what the AI concluded but how much to believe it.
This is why the products that feel genuinely well made right now tend to answer three quiet questions at the moment of output. Where did this come from? How confident should I be? What do I do if it’s wrong? Perplexity’s inline citations are the obvious example, source links sitting next to claims so you can check the ones that matter and ignore the ones that don’t. It’s a small pattern. It’s also the whole ballgame, because it converts a confident-sounding answer into something a person can actually calibrate against. Provenance, confidence, and correction are the new honesty. They are Rams, relocated.
The interface stopped being the product
The bigger shift is structural. For thirty years you could point at a rectangle and say I designed that. Mastery meant fluency in layout, hierarchy, state, the grid. That era was real and it worked. It’s also ending, because the most important design problems no longer live inside a fixed screen. They live inside systems that read context, infer intent, and act, sometimes without waiting to be asked.
When a product takes action on your behalf, a new set of design principles becomes non-negotiable, and none of them are visual. Transparency into what the agent is about to do. Control to override or stop it at any step. Status, so the person isn’t staring at a spinner wondering what’s happening. And structured recovery for when it fails, because agent failures don’t degrade gracefully. A normal bug gets reported and patched. An agent that books the wrong flight or sends the wrong message doesn’t just cause an error, it causes the user to revoke the autonomy they’d granted, and winning that permission back is a far harder design problem than preventing the mistake was.
The teams building this well have noticed something humbling: most problems that show up as AI problems are old system-design problems that were survivable until an agent made them visible at speed. Inconsistent labels, muddled hierarchy, a workflow a new hire couldn’t follow without help. Humans route around that friction. Agents fail on it, faster and at scale. So the unglamorous center of good design in this era is the layer nobody sees. Fix the system first. The prettiest chat interface in the world can’t rescue a product whose underlying model of the work is incoherent.
Restraint is the skill the model can’t have
Which brings me back to the small app I keep building, the one for rehearsing hard conversations before you have to have them for real. Every time I ask a tool to generate a screen for it, the tool gives me more. Another card, another metric, a progress ring, an encouraging badge. The model has no reason to say no, because it’s producing the statistically likely version of a wellness app, and the statistically likely version is cluttered with reassurance.
But the entire point of the product is that you arrive nervous and shouldn’t be met by a scoreboard. So I keep deleting. The practice screen is one transcript of what you actually said and one honest observation about it. No score. That decision is invisible, it took ten minutes, and it’s the only part anyone remembers. Rams called it as little design as possible. In an age of generation, “as little as possible” stops being an aesthetic preference and becomes an act of resistance against a system whose default is always more.
That’s the pattern underneath all of it. AI raised the floor of competence so high that competence stopped being worth anything, and everything it can’t do got more valuable, not less. Knowing which generated direction fits this specific user’s mental model, when the averaged model in the machine has no idea who your users are. Deciding what to leave out. Designing the moment of honesty. Building the system so an agent can’t quietly do harm. None of that scales with compute. All of it is judgment, and judgment is exactly what a model trained on the average can’t originate.
The question worth arguing about
So here’s where I’ve landed, at least this week. Good design was never really about the artifact. It was about a person deciding, on purpose, what a thing should and shouldn’t do, and taking responsibility for the answer. AI didn’t take that away. It stripped out everything around it, all the execution that used to disguise the absence of a decision, and left the decision standing there, exposed.
Which means the durable question isn’t which tool you use. It’s the one Rams was really asking the whole time. Is this good, and how would you know? If the model can’t answer that for you, and it can’t, then the answer is the only thing you’re actually being paid for. Where’s yours coming from?
References
IxDF, “Dieter Rams: 10 Timeless Commandments for Good Design”: https://ixdf.org/literature/article/dieter-rams-10-timeless-commandments-for-good-design
Zalando Design, “In the AI age, timeless principles are designers’ best guide”: https://medium.com/zalando-design/timeless-design-principles-for-the-ai-age-83cb6da5dd55
Ascedia, “What Good AI UX Actually Looks Like in 2026”: https://www.ascedia.com/insights/what-good-ai-ux-actually-looks-like-in-2026
Armaan Ranjan Jha, “How to design AI features that users actually trust”: https://medium.com/@armaanranjanjha/how-to-design-ai-features-that-users-actually-trust-6ed5c0bf22d8
Fuselab Creative, “Agent UX: UI Design for AI Agents in 2026”: https://fuselabcreative.com/ui-design-for-ai-agents/
Alexandra Vasquez, “Agentic UX: 7 principles for designing systems with agents”: https://medium.com/design-bootcamp/agentic-ux-7-principles-for-designing-systems-with-agents-019512c2caa9
Tejj, “State of Design 2026: When Interfaces Become Agents”: https://tejjj.medium.com/state-of-design-2026-when-interfaces-become-agents-fc967be10cba
Arounda, “40 Best Digital AI Product Design Examples in 2026”: https://arounda.agency/blog/product-design-examples