What happens when the city you live in becomes a little too loud?

For thousands of New Yorkers, noise is more than a passing annoyance. It’s a daily disruption, and one that more than 610,000 noise complaints submitted to NYC 311 every year attempt to address.

But reporting a problem is only one part of the experience. What happens after you hit submit? Do residents know if anything is being done? And how can a city make people feel heard?

These were some of the questions I began exploring through Civic by Design 2026, hosted by AIGA and Designpreneurs, powered by Figma. The challenge was to rethink how New York City addresses its noise problem.

When I first approached the challenge, I saw the more than 610,000 noise complaints submitted to NYC 311 every year as an opportunity to improve the reporting experience. But the more I researched, the more I realized that the problem went far beyond simply submitting a complaint.

What happens afterward? How do residents know their complaints are being addressed? Could neighbors resolve issues together? How might existing technology make the experience more accessible?

Every question uncovered another layer.

I explored a new approach to this pressing issue faced by New Yorkers through Trace, a concept that reimagines NYC’s noise complaint experience through greater transparency, accessibility, and community connection.

Rather than creating another standalone reporting tool, I explored how NYC 311, voice assistants, connected devices, and community interactions could work together.

The experience focuses on four pillars:

• Transparency: Giving residents visibility into complaint progress and resolution.
• Community: Connecting neighbors through shared noise reports and neighborhood patterns.
• Accessibility: Making noise reporting and follow-ups easier through familiar, everyday technologies.
• Reassurance: Helping residents feel heard and informed by providing clarity, feedback, and a sense of progress throughout the process.

What made this challenge different was the freedom to question almost everything. Unlike working on an existing product, where established systems and expectations often define the boundaries, civic design allowed me to explore the many layers of a problem before deciding what the solution should look like.

A few things I took away:

• Don’t rush to the interface. Sometimes the biggest opportunities are hidden beneath the initial problem statement.
• Think in systems, not just screens. People, services, technology, and real-world interactions are all part of the experience.
• Question existing assumptions. Not every problem needs another app or an entirely new system. Sometimes the opportunity is to connect what already exists.

I enjoyed this challenge because it reminded me that design isn’t always about improving what’s already there. Sometimes, it’s about questioning the way we’ve been looking at a problem all along.

And perhaps the most interesting part of designing is realizing just how much more there is to uncover.

Explore Prototype → (experienced best on mobile)
View Case Study →

I want to start with a weird question I can’t stop thinking about: why do we tell our smart home devices things we wouldn’t tell our own family?

Think about it. You skip the “how was your day” with the people you love, but your phone, your watch, and that little speaker on the counter hear about your stress, your sleep, and your 2am snack cravings. They’re always listening, and they know a lot.

That’s the tension I kept running into while designing ORI, my thesis project. And it changed how I think about designing for the home.

The invasion line is blurry

Every time you design for a home device, you’re deciding what the tech gets to know. Too little and it’s useless. Too much and it feels creepy.

I don’t think there’s a perfect answer. But I do think this: once the information is already out there, the product owes you something back. It should help you celebrate a win, nudge you when you’re drifting, or just hear you out. If a device knows everything about you and gives you nothing in return, that’s a bad deal.

ORI is designed to work with wearable data, but you never have to read a number or a graph. It turns that data into light, sound, and gentle prompts. The data goes in, and a ambient cue comes out. Nobody opens a dashboard and tries to decode their heart rate at 9pm.

Notification fatigue is a real design problem

Here’s what pushed me to build this. When I researched wellness tech, the numbers were rough:

• 48% of people deal with notification fatigue
• 69% struggle with work-life boundaries
• 60% feel overloaded juggling multiple apps

So the tools meant to make us healthier are adding to the noise. More screens, more buzzing, more “you have 3 new insights!”
That’s a UX failure, not a user failure.

My goal with ORI was to do the opposite. Filter the noise, and deliver fewer nudges at the right time. Not every nudge, just the ones that matter. Not on a screen, but in the room you’re already in.

The hard part: a companion without a relationship

This is the part I wrestled with most. How do you design a conversational companion without ever defining the relationship?

Is it an assistant that answers your questions? A notification machine? Or is it smart enough to act like an old friend, someone who just gets it without you explaining every little detail back and forth?

My take on conversational UX: it’s about defining the relationship between the device and the human and drawing clear boundaries around it. The flow, the tone, and when it speaks up versus stays quiet are all part of that. A good friend knows when to say something and when to just sit there with you.

Devices have a head start because they already have all your information. But empathy is the thing that makes that information worth anything, and that part is on us as designers. We should aim it at making devices smarter for people, not the other way around.

One device, a whole household

Homes aren’t single-user spaces, and this is where it got fun for me. I designed ORI as a multi-user, multi-mode, multi-wearable touchpoint, so one hub can serve everyone who lives in the space. It eases three things:

1. Clutter. Fewer separate gadgets competing for space in your calm corner of the home.
2. A shared device with personal features. Without that, it’s just another night lamp or alarm clock.
3. Becoming everyone’s companion, in its own way. The same object can feel different to each person using it.

Five stories, one device, a hundred nudges, all once ORI and a wearable are paired.

I also kept asking myself small, practical questions from my early notes. Can it wirelessly charge your phone, watch, and AirPods? Can it have modes that control digital noise and notifications? Can it look ambient and aesthetic enough that you’d actually want it in your living room? A device that fights your decor loses before it starts.

Where this could go

I think ORI belongs inside the platforms people already use. I picture ORI as a wellness layer within Apple Home, Google Home, and Alexa, so the home becomes proactive instead of just reactive. It anticipates and guides your day instead of waiting for you to shout a command at it.

I built a 3D printed working prototype of ORI and showed it at an exhibit. Seeing people interact with something physical taught me more than any wireframe did.

A Smarter Home Should Know When to Be Quiet

The future of the smart home isn’t about building devices that know more about us. It’s about designing devices that know what to do with what they already know.

As designers, we have to look beyond what technology can sense, predict, and automate, and ask what it should do with that knowledge. When should it step in? When should it stay quiet? And how can it make someone feel understood without making them feel watched?

With ORI, I wanted to explore a home that doesn’t demand more of your attention, but gives some of it back. A home that doesn’t need another screen, another notification, or another number to tell you how you’re doing. Sometimes, a little light at the right moment is enough.

What I’d tell fellow designers

If you’re designing for the home, here’s my cheat sheet:

• Ask what the tech actually needs to know. Don’t collect just because you can.
• Reduce noise before adding features. Every new nudge has to earn its place.
• Use the environment. Light, haptics and sound can say what a notification can’t.
• Define the relationship. Decide what your product is to the person, and stick to it.
• Lead with empathy. The data is the easy part. Using it kindly is the work.

The best home tech won’t be the one that knows the most about you. It’ll be the one that knows when to say something, and when to let you breathe.

Because a home that knows you is smart. A home that knows what you need, when you need it, and when to leave you alone? That’s thoughtful design.

Designing for a Home That Understands You was originally published in UX Planet on Medium, where people are continuing the conversation by highlighting and responding to this story.

I asked a voice assistant to turn off “the lights” in a room with three lamps. It picked one, confidently, and left the other two on. Not because it misheard me, it understood every word. It just had no way to ask which lamp I meant, because nothing about the interaction gave it a path to clarify. On a screen, that’s a two-tap fix. In voice, there was no fallback, just a wrong guess delivered with total confidence.

That’s usually the moment people write voice off. I think it’s the opposite signal. The failure wasn’t voice as a medium, it was a screen-shaped decision tree wearing a microphone. Nobody designed a real fallback for ambiguity, because most voice products are still built like a menu read aloud. That’s a solvable design gap, not a ceiling on the medium.

Why the bar looks higher than it is

Voice gets judged more harshly than screens because every flaw is felt in real time. A cluttered app screen is still usable, you scroll past what you don’t need. A cluttered voice response isn’t usable at all, you have to sit through it. That makes voice unforgiving of lazy design. It doesn’t make it a worse medium, it makes it one where good design is the entire product, not a nice-to-have layered on top.

That’s actually the opportunity. Screens have decades of accumulated convention to lean on, even mediocre screen design gets by on borrowed patterns. Voice has almost none of that yet. Whoever actually solves ambiguity handling, graceful clarification, knowing when to say less, gets to set the pattern everyone else copies for the next decade. That’s a much better position to build from than fighting for the millionth iteration of a card-based layout.

Ambient and conversational surfaces are proof the appetite is already there

Ambient computing and conversational AI have both exploded precisely because people want to interact without a screen in front of them, cooking with wet hands, driving, lying in bed at night. That demand didn’t wait for voice UX to mature. It’s already showing up in every “hey, can you just tell me” moment people have with their devices. The appetite is ahead of the execution, which is exactly the gap worth designing into.

Where a screen is the wrong default, not just an option

Tapping and swiping had to be taught. An entire generation learned pinch-to-zoom from nothing, it wasn’t intuitive, it became intuitive through repetition. Speech didn’t need that training. A two-year-old can ask for something before they can point precisely enough to tap it. That’s not a minor UX detail, it’s the reason voice fits situations screens were never built for, not because screens are bad, but because reaching for one is often the extra step, not the natural one.

Setting a timer with flour on your hands. Adding a line to a grocery list while driving. Logging a workout mid-set instead of stopping to unlock a phone. Pulling up one specific fact, a flight time, a conversion, a definition, without opening an app to get to it. In every one of these, a screen isn’t a neutral tool, it’s friction: find the device, unlock it, find the app, find the field. Voice collapses that whole chain into the same gesture people already use to ask another person for help.

The mistake is treating voice as a screen substitute, a smaller, clunkier way to do what an app does. It’s better understood as a gesture, the same category as pointing or nodding, just one that happens to carry more information. Designed that way, entire flows stop needing a screen at all instead of getting a worse, voice-shaped copy of one.

What “designed for voice” actually looks like

Concretely: systems that ask one clarifying question instead of guessing, that know the difference between a one-word answer and a paragraph nobody asked for, that treat silence as a valid design choice instead of dead air to fill. None of that requires better AI models, most models are already fluent enough. It requires designers willing to treat voice as its own discipline instead of a screen’s audio export.

What Siri and Alexa already prove, and where they still trip

Ask Alexa to set a five-minute timer while your hands are covered in raw chicken, and it’s genuinely better than any screen could be, no unlocking, no searching, done before you’d have found the app icon. That’s not a minor convenience, it’s a task screens were always going to lose at. Millions of people use these devices daily for exactly that class of request, because for a single, bounded, unambiguous ask, voice is the fastest interface that’s ever existed.

The friction shows up the moment a request stops being bounded. Ask Siri to “move my 3pm to tomorrow, and check if that clashes with the thing Vrushti sent,” and it stalls, not because the AI model can’t parse the sentence, but because nobody designed what the system should do when a request has multiple steps and a little ambiguity baked in. So it either fails outright or picks one narrow reading and runs with it, confidently, like the lamp. The lesson isn’t “voice can’t handle complexity.” It’s that today’s voice products were designed for single commands, then complexity got bolted on later instead of designed for from the start.

What comes next won’t feel like commands, it’ll feel like delegation

The next real shift in voice and conversational UX isn’t better speech recognition, that part is basically solved. It’s systems that can hold a multi-step ask, admit uncertainty out loud instead of guessing, and check in at exactly the right moment instead of every moment or none. Less “Alexa, set a timer,” more “hey, can you handle rescheduling this and let me know if anything conflicts,” the way you’d hand something off to a competent assistant, not program a remote control.

That future doesn’t replace screens. It just stops asking voice to prove itself as a screen with a microphone bolted on. The products that get there first won’t be the ones with the best AI model. They’ll be the ones that finally designed for what happens when the request isn’t simple, because that’s the actual ceiling voice has been hitting all along.

💡 Stay inspired every day with Muzli!

Follow us for a daily stream of design, creativity, and innovation.
LinkedIn | Instagram | Twitter

Voice UX Is Underused, and That’s the Opportunity was originally published in Muzli - Design Inspiration on Medium, where people are continuing the conversation by highlighting and responding to this story.

Open Google Maps, search “coffee near me,” and you’ll get exactly what you asked for: a list. Ratings, distance, maybe a photo. What you won’t get is an answer to the question you actually had, which was never “show me coffee shops,” it was “which one should I go to.” To answer that, you’re now doing the comparison yourself, manually, across four different browser tabs or app taps: checking parking on one, reservations or crowd levels on a review site, whether the route still gets you to your 3pm on time. Maps hands you the raw material and quietly outsources the hardest part of the decision back to you.

That gap, between information and an actual decision, is the problem I’ve been designing against in a personal case study: a reimagined comparison experience for Google Maps, where you can pick two or three places yourself and see them side by side, directly on the map, with the specific details that actually decide where you go: distance, route by transport mode, parking, crowd, hours, and whether you’ll still make your next calendar event.

It’s a small feature. But working on it changed how I think about what my job even is right now, and it’s made a talk I recently watched, “Future-Proofing Your Design Career in the Age of AI,” feel a lot less theoretical.

From T-shaped to blob-shaped, mid-project

I went into this project thinking of it as an interaction design problem. Card layouts, information hierarchy, how many attributes fit on a screen before it’s cluttered. That’s the T-shaped version of me showing up: one deep lane, everything else secondary.

It didn’t stay that way. Deciding what the comparison should even show meant thinking like a product strategist, what data actually changes someone’s decision versus what’s just noise. Getting the map-anchored cards to feel right meant thinking about motion, how a card should behave when you pan or switch transport modes without breaking your sense of place. Explaining the whole thing in a case study meant thinking like a storyteller, because a stack of screens with no narrative around them is just a portfolio nobody remembers.

None of that fits under one job title. It’s not that my depth in interaction design stopped mattering, it’s that the boundary around it stopped being useful the moment the problem needed something else. That’s the fluid-shaped shift in practice: not abandoning a specialization, just refusing to let it be the only shape you’re allowed to take.

The decision that had to stay mine

Early on I let an AI tool auto-suggest which locations to compare. Search “coffee,” get three AI-picked candidates, done. Fast, and wrong. Comparison only means something if the user chose what’s being compared, maybe they already know they want the place with parking, maybe they’re loyal to a spot because the barista knows their order. An AI ranking can’t know that, and letting it decide quietly deleted the one part of the interaction that was actually personal.

So I reversed it: the user searches and selects their own candidates. That call didn’t come from a pattern AI could complete, it came from having stood on a sidewalk myself, annoyed, trying to decide where to go. That’s lived empathy doing something a simulated user model can’t: knowing that autonomy is the feature, not the friction.

Where the story does the work the screens can’t

A comparison UI with parking, crowd data, and a calendar check sounds like a feature list, not a reason anyone should care. What makes it land in a case study is the story underneath it: the specific moment of standing between two places, phone in hand, running out of time. Visuals alone would make this look like a spec sheet. The narrative is what turns it into something a reviewer, actually remembers and connects to a real frustration they’ve had themselves.

Taste, twelve times over

Once the cards needed to live on the map instead of a separate list screen, I used AI-assisted tools to throw out a dozen layout directions fast: docked at the bottom, floating over pins, collapsing on pan, staying pinned. Genuinely useful, I could not have hand-mocked that many spatial variations in an afternoon.

Exactly one of those twelve made it into the prototype. Generating options was the easy part, and it’s gotten easier by the month. Recognizing which one actually respected the map, didn’t block the pins, and held up when someone panned around, that took taste, not generation speed. That’s becoming the real differentiator: not who can produce the most variations, but who can tell which one deserves to survive.

Co-creation, not outsourcing

Looking back, the pattern across this whole project is consistent. AI was excellent in the messy divergent phase, throwing layout options, remixing directions, moving faster than I could alone. It had no business making the one decision that defined the whole feature: what the user gets to choose for themselves. Automation would have handed me a finished, forgettable version of this feature. Treating AI as a collaborator in the exploration, while keeping the actual judgment calls mine, is what made it feel like a feature I’d actually trust.

What the job actually is now

I used to think of my job as making screens. This project made it clear it’s really about making decisions grounded in human empathy, about what a user needs, about which AI-generated option deserves to ship, about when speed is a shortcut and when it’s a cop-out. The screens are just where those calls end up visible. None of that fits neatly into a job title, and I’m increasingly convinced that’s the point.

AI Can Generate Twelve Layouts. It Can’t Tell Me Which One to Ship. was originally published in UX Planet on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Paradox

Imagine something breaks on a product that thousands of people are using. Right now. The team gets an alert, someone opens a dashboard, and suddenly they’re staring at a wall of numbers, graphs, and color-coded warnings, all updating in real time.

The tool is doing its job. It’s showing everything. But “everything” is the problem.

DevOps tools, the software that monitors whether apps and systems are healthy sit at one of the most stressful moments in tech. Something is wrong, people are affected, and every second counts. You’d think the interfaces built for these moments would be ruthlessly clear. Calm, even. Designed to cut through chaos, not contribute to it.

Most of them aren’t.

Instead, they’re dense. Busy. Built around data, not decisions. They show you hundreds of metrics when what you actually need is one answer: what do I do right now?

That gap between what the tool shows and what the person actually needs, is a design problem. And it’s one that the industry has been slow to take seriously.

This isn’t about making these tools prettier. It’s about understanding why they’re so hard to use in the first place, and what it would take to actually change that.

Root Causes

To understand why DevOps tools feel the way they do, you have to understand who built them and why.

Most monitoring tools were created by engineers, for engineers. That’s not a criticism, it’s just context. The people who built them were also the people using them, so the design decisions made sense at the time. More data meant more control. More visibility meant fewer surprises. The goal was comprehensiveness, and the tools delivered exactly that.

But comprehensiveness and clarity are not the same thing.

Over time, these tools grew. More integrations, more metrics, more alert types, more customization. Each addition was technically useful. Cumulatively, they created something that takes months to learn and never quite feels intuitive, even for the people who use it every day.

A few patterns show up again and again:

Data without context. A graph spiking doesn’t tell you if that spike is normal for a Tuesday morning or a sign that something is about to go wrong. The number is there. The meaning isn’t.

Alerts without priority. When everything is flagged, nothing feels urgent. Teams learn to ignore certain alerts because they fire constantly and rarely mean anything. That’s a dangerous habit to build into a workflow.

Dashboards built for display, not decision-making. There’s a difference between a screen that shows you the state of a system and one that helps you act on it. Most monitoring dashboards are the former. They’re impressive to look at. They’re hard to use under pressure.

Assumed expertise. These tools often drop you into the deep end, no guided setup, no progressive introduction to what you’re looking at. If you don’t already know what a p99 latency means or why a memory leak matters, the interface won’t explain it to you.

The Designer’s Lens

When designers look at a complex system, the instinct isn’t to simplify it into something it’s not. It’s to find the right layer of complexity for the right person at the right moment.

That distinction matters a lot in DevOps tools, because the answer isn’t to strip out data or dumb things down. Engineers need depth. But depth doesn’t have to mean disorder.

Here’s how some core design principles apply directly to this problem:

Progressive disclosure. Not everyone who opens a dashboard needs to see everything at once. A senior engineer debugging an active incident has different needs than a product manager checking on a deploy. Good design surfaces the most critical information first and lets people go deeper when they need to rather than presenting everything at the same visual weight, all the time.

Information hierarchy. Our eyes naturally move toward contrast, size, and color. But in most monitoring dashboards, everything competes equally for attention. When every panel looks the same, nothing stands out. Hierarchy isn’t decoration, it’s how you tell someone where to look first.

Status visibility. One of the most fundamental principles in UX is that users should always know what’s happening. In high-stakes tools, this means more than a green or red dot. It means communicating why something is in that state, how long it’s been that way, and whether it’s getting better or worse. Context is part of status.

Error prevention over error recovery. Most monitoring tools are built around reacting to problems after they happen. But design can push earlier, smarter alert thresholds that learn from patterns, defaults that reduce false positives, onboarding that helps teams set up meaningful signals before something breaks.

These aren’t new ideas. They’re principles that have existed in UX for decades. The interesting question is why they haven’t made their way into this corner of the industry and the honest answer is that design hasn’t had a seat at the table. These tools have been roadmapped by engineering teams optimizing for capability, not usability. That’s starting to change. But slowly.

What Fixing It Actually Looks Like

“Better UX” in a DevOps tool doesn’t mean a cleaner color palette or a redesigned logo. It means changing what the interface prioritizes and for whom.

Smarter defaults. Most tools ship with dashboards that show everything and highlight nothing. Defaults should be opinionated surface the metrics that matter most for a typical team, and let people customize from there rather than build from scratch.

Alert triage, not just alert volume. Instead of a feed of every warning firing at once, what if the interface grouped related alerts, suppressed known noise, and surfaced the one thing most likely to need human attention? Less inbox, more signal.

Guided context. When something looks wrong, the tool should help you understand why not just show you the anomaly but connect it to a recent deploy, a traffic spike, or a pattern it’s seen before. That’s the difference between data and insight.

Designing for the whole team. Not everyone looking at these dashboards is an engineer. Making certain views accessible to product managers, designers, or executives without watering down the technical depth for those who need it, is a solvable problem. It just requires intention.

None of this requires throwing out what already works. It’s about layering better decision-making support on top of powerful infrastructure that already exists.

Why It Matters Now

Here’s the thing about this moment: every major DevOps tool is racing to add AI. Anomaly detection, natural language queries, automated root cause analysis. The pitch is that AI will finally make sense of all that complexity.

But AI doesn’t fix a broken foundation. If the underlying experience is noisy, disorganized, and built without the user in mind adding intelligence on top of it just creates smarter chaos.

For AI features to actually work, the interface around them has to be trustworthy. Users need to know what the AI is doing, why it surfaced something, and when to override it. That’s not an engineering problem. That’s a design problem.

This is why designers need to be in the room earlier in companies like this, not to make things look good, but because the decisions being made right now about how AI gets layered into these tools will shape how engineers work for the next decade. Someone needs to be asking: does this actually help the person under pressure at 2am? Is this adding clarity or just adding another panel to the wall?

Complex domains don’t need less design. They need better design. And the designers who can get fluent in that complexity, who can sit with engineers, understand the systems, and still advocate for the human on the other end, are the ones who will do the most meaningful work in the years ahead.

That’s the kind of designer worth becoming.

There’s a quiet irony at the heart of the screen detox movement. We downloaded apps to track our screen time. We set phone-free hours. We bought alarm clocks so we didn’t have to reach for our phones in the morning. And then we strapped a glowing rectangle to our wrists and called it wellness.

The first wave of smartwatches didn’t really solve the problem. They just moved it closer to our bodies. Every buzz on the wrist became a new trigger, a new reason to look, tap, scroll. In practice, bringing notifications to the wrist often resulted in an increase in total screen time and a heightening of the “attention economy,” where every vibration served as a trigger to engage with a digital platform. News-articles

But something shifted. And the devices leading that shift don’t have screens at all.

The Screenless Revolution

A new generation of wearables is emerging. One that values discretion, simplicity, and ambient intelligence over flashy displays and constant notifications. Smart rings, no-display health monitors, and gesture-based controllers are devices so subtle, they often go unnoticed.

WHOOP is the clearest example. Its screenless design makes it significantly more discreet than most wrist wearables, and WHOOP Body clothing which hides the tracker in garments means its versatility is unmatched.

You wear it. You forget it’s there. It works.

Oura Ring took it further, shrinking the entire concept of a health tracker into something that looks like jewelry. Its minimalist design helps reduce screen time and is less bothersome during sleep, while still tracking heart rate variability, body temperature, and detailed sleep cycles. There’s no display to compulsively check. The data is waiting for you when you decide to look, not the other way around.

This is a fundamental UX reversal. Traditional apps are pull-to-refresh, always-on, designed to keep you coming back. These devices flip the relationship: passive collection, intentional review.

Ambient Intelligence vs. Notification Anxiety

The design philosophy here isn’t minimalism for its own sake. It’s about when information reaches you.

The most useful wearable moments often happen when the user’s hands, eyes, or attention are already occupied. A haptic nudge to breathe. A gentle morning summary. A readiness score that tells you whether to push hard or rest delivered once, clearly, without demanding your attention all day.

The removal of the screen eliminates the impulse for doomscrolling or the anxiety triggered by a sudden influx of work emails during a workout or a period of rest. The data becomes a tool for long-term trend analysis and habit formation, not a feed to consume.

This is the UX insight the next generation of wearables got right: connection doesn’t require a screen. Awareness doesn’t require an interface.

Big Tech Is Paying Attention

Competitors like WHOOP, Oura, and Google’s Fitbit are gaining ground against the Apple Watch by focusing on discreet, screenless designs that emphasize passive monitoring of recovery, sleep, and overall health without the constant distractions of notifications or bright displays.

Apple and Samsung are now embracing the possibility of Oura-style smart rings, a telling sign that the industry has accepted what users already figured out: sometimes the best interface is no interface.

The Real Detox

The screen detox movement was never really about screens. It was about agency, the feeling that technology was happening to you, not for you.

Wearables that collect passively and report intentionally give that agency back. You’re still connected. You’re still tracked. But you’re in control of when it surfaces. That’s not a contradiction, it’s the most sophisticated UX design in years.

The best interface might just be the one you forget you’re wearing.

Screen Detox, But Make It Wearable was originally published in UX Planet on Medium, where people are continuing the conversation by highlighting and responding to this story.

You clicked a button.
The system responded.
Cause and effect were clear.

Agentic design changes that relationship entirely.

Instead of waiting for instructions, systems now act on our behalf. They understand goals, make decisions, and execute multi-step actions sometimes without direct input. This shift unlocks enormous value, but it also disrupts the quiet, unspoken contract humans have built with technology over time.

To understand why agentic design is both powerful and unsettling, we need to unpack what it does, why people adopt it, and how it fundamentally reshapes trust.

From Tools to Delegates: What Agentic Design Does

Agentic UX design is about designing how humans delegate work to intelligent systems safely, clearly, and confidently.

In an agentic system, users don’t just operate an interface. They set intent, and the system takes responsibility for execution.

An agent is typically an AI-powered system that can:

• Understand goals and context
• Make decisions
• Take actions across steps or tools
• Learn and adapt over time

This means the user experience is no longer about guiding someone through screens and forms. It’s about designing delegation, oversight, and collaboration between humans and systems.

Instead of:

“Click here, then here, then submit”

The interaction becomes:

“Handle this for me.”

Agentic design moves UX away from task completion toward outcome ownership.

How Agentic Systems Support Human Focus

Despite the discomfort they introduce, people adopt agentic systems for one simple reason: they reduce cognitive and operational load.

1. Complexity Is Breaking Humans

Modern digital work involves:

• Too many tools
• Too many decisions
• Too many steps for simple outcomes

Agentic systems collapse this complexity by taking on orchestration connecting tools, sequencing actions, and managing follow-through.

2. Delegation Scales Better Than Attention

Humans are bad at:

• Repetitive tasks
• Long chains of execution
• Constant context switching

Agents excel at exactly these things. When designed well, they free humans to focus on judgment, creativity, and strategy instead of mechanics.

3. Outcomes Matter More Than Process

Most users don’t care how something gets done only that it’s done correctly, on time, and in line with their intent.

Agentic design optimizes for results, not steps.

Where Trust Starts to Crack: How Agentic Design Defies It

This is where things get complicated.

Agentic UX doesn’t just add autonomy it breaks the assumptions that made technology feel trustworthy in the first place.

1. The Disappearance of Explicit Control

Traditional interfaces rely on visible actions:

• Click = consent
• Submit = responsibility

Agentic systems act between interactions. Decisions may happen without a clear “yes” moment.

This creates discomfort because humans equate control with trust.

When something happens without a clear action, users ask:

• Did I approve this?
• Could I have stopped it?

Trust erodes when consent becomes implicit rather than explicit.

2. When Accountability Has No Clear Owner

With tools, responsibility is clear:

“I made that mistake.”

With agents, responsibility is shared or worse, unclear.

If an agent sends the wrong email, books the wrong flight, or makes a poor decision:

• Was it user intent?
• System interpretation?
• Model behavior?
• Business logic?

Humans are deeply uncomfortable when blame has no clear home. Agentic design forces UX to answer questions technology never had to answer before:

• Who decided this?
• Why?
• Can I undo it?

3. Predictability Breaks and So Does Trust

We trust technology because it behaves the same way every time.

Agentic systems:

• Learn
• Adapt
• Change behavior over time

Even when these changes improve outcomes, unpredictability feels unsafe.

When users think:

“It didn’t do this last time”

Trust weakens.

Agentic UX must prioritize behavioral consistency and explanation over clever optimization.

4. The Illusion of Control Starts to Fade

Humans don’t need full control, they need to feel in control.

Agents operate faster, across more systems, and with more information than users can track. This creates a power imbalance:

“I don’t know what it’s doing, but it’s doing a lot.”

Without visibility, autonomy feels like loss, not help.

5. When Tools Start Feeling Like Teammates

Agentic systems behave less like software and more like collaborators.

Humans instinctively apply social expectations:

• Judgment
• Reliability
• Ethics
• Intent

We forgive tools when they fail.
We judge agents.

When an agent makes a mistake, it feels personal even when it’s not. This emotional shift raises the bar for design maturity and ethical responsibility.

Agentic Design in the Real World

Agentic design isn’t theoretical. We’re already interacting with it daily often without realizing how much trust we’re placing in these systems.

Notion AI: From Editor to Co-Author

Notion AI doesn’t just autocomplete text. It:

• Summarizes documents
• Drafts content from vague prompts
• Suggests next steps based on context

This shifts the user’s role from writer to editor. Trust is required because:

• The system interprets intent, not explicit instructions
• It makes assumptions about tone, structure, and relevance

Notion mitigates trust issues by:

• Keeping outputs editable
• Avoiding irreversible actions
• Making the agent feel assistive, not authoritative

The design choice here is intentional restraint autonomy without ownership.

GitHub Copilot: Delegating Thought, Not Responsibility

Copilot operates in a deeply agentic way. It predicts developer intent from partial code, suggests entire functions rather than isolated lines, and gradually adapts to individual coding patterns over time reducing effort without taking control.

Developers adopt Copilot because it reduces cognitive load but they don’t fully trust it.

That’s why Copilot avoids automatic commits, requires human review, and presents suggestions as temporary and easily reversible.

The UX preserves trust by ensuring humans remain accountable, even as the system becomes increasingly proactive.

Calendar Agents: Trust at the Edge of Social Boundaries

Calendar agents that schedule meetings or negotiate availability are among the most trust-sensitive agentic systems. To function effectively, they read across emails and calendars, make social decisions on the user’s behalf, and communicate autonomously with other humans — often outside the user’s immediate visibility. Because these actions sit at the intersection of productivity and social norms, even small missteps can feel intrusive or uncomfortable, making trust a central design requirement rather than a technical afterthought.

A poorly designed calendar agent can:

• Overstep social norms
• Expose private context
• Create awkward or damaging interactions

Successful calendar agents:

• Ask before sending external messages
• Show previews of proposed actions
• Allow strict boundaries (“never book during X”)

Here, trust isn’t just technical, it’s social.

What These Examples Reveal About Trust

Across Notion, Copilot, and calendar agents, a clear pattern emerges:

• Users accept autonomy when reversibility is easy
• Trust increases when systems explain intent
• Adoption accelerates when agents act like collaborators, not decision-makers

These products succeed not because they are intelligent but because they are careful.

Why Agentic UX Design Matters Now

Agentic systems are inevitable. The complexity of modern work demands them.

But trust is no longer something UX can assume it must be designed deliberately.

Agentic UX designers are now responsible for:

• Making autonomy legible
• Designing consent without friction
• Calibrating trust over time
• Supporting recovery and undo
• Balancing efficiency with human comfort

The success of agentic systems won’t depend on how intelligent they are but on whether humans feel safe delegating to them.

The Core Paradox of Agentic Design

Agentic systems are most useful when they act independently but most trusted when they act transparently.

Agentic design exists to resolve this tension.

Not by removing autonomy but by making it understandable, accountable, and human-centered.

Designing Trust in the Age of Agentic Systems was originally published in The Next Era Journal on Medium, where people are continuing the conversation by highlighting and responding to this story.

Exploring the Promise of Circular UI in a Post-Grid World

When we picture a digital interface, most of us immediately visualize neatly arranged grids structured, clear, and rectangular. For decades, this geometry has provided consistency and clarity in the digital world.

But what if we expanded that toolkit?

As interactions evolve beyond traditional screens and into smart rings, home hubs, wearables, and spatial computing, new modes of engagement are emerging. It’s time we explore design patterns that better align with these multisensory, responsive environments.

I believe one of the most promising directions is circular UI.

A Familiar Shape, An Untapped Language

Circular design is not new but its use in UI remains remarkably under-explored. While we see circular elements in physical devices from thermostats to fitness trackers few systems have fully embraced circular-first digital interfaces.

This isn’t due to a lack of user intuition. Circles are among the most universally recognized and emotionally resonant shapes. They appear in nature, architecture, timekeeping, and symbolism. Their form suggests completeness, flow, and safety.

And now, as interaction expands beyond swipes and taps to include voice, gesture, haptics, and gaze, circular UI offers a natural foundation for rethinking how we engage with technology.

Designing Circular UI with Existing Principles

Circular design doesn’t require abandoning everything we know — it asks us to adapt our existing systems to new geometries. Many familiar design principles can be translated into circular contexts:

Hierarchy through proximity: Instead of vertical stacks, spatial positioning in radial layouts can indicate importance and frequency.

Gestalt principles like closure and continuity translate beautifully in radial symmetry, enhancing user flow and scan-ability.

Information architecture can follow orbital models, with central content surrounded by layers of depth prioritizing clarity over complexity.

Interaction design can introduce new patterns like rotational inputs, circular swipes, ring animations that feel tactile and intuitive.

By rethinking placement, movement, and form within a circular framework, we can build interfaces that are not only functional, but emotionally grounded and engaging.

Cognitive Simplicity in a Noisy World

In today’s digital environments, cognitive overload is a growing concern. Notifications, infinite scrolls, and dense UI layouts can overwhelm even the most tech-savvy users.

Circular UIs, by nature, encourage focused, bounded interaction. They reduce decision fatigue by containing options in a defined space and gently guiding the eye from center to periphery. Studies show that radial interfaces can improve decision speed by up to 30% and increase motor accuracy on small devices by over 20%.

Paired with haptic feedback, voice cues, and subtle motion, circular UIs create an immersive and calming interaction layer especially important in wellness, accessibility, inclusivity and ambient tech contexts.

Creating the Grids That Don’t Exist (Yet)

Because most design systems and layout tools are built for rectangular logic, I’ve pushed myself to prototype custom circular grids drawing from nature, geometry, and information flow.

Using Fibonacci sequences, golden ratios, and radial symmetry, these explorations revealed how circular UI could be both functional and beautiful. Instead of thinking in rows and cards, I began to think in orbits, nodes, and breathing space. Each element had a relationship not just to the screen but to its position in a living system.

These layouts invite interaction that is more fluid, spatial, and emotionally attuned paving the way for interfaces that feel less like tools and more like companions.

Rethinking Intuition

At first, I questioned why circular UI wasn’t more common. Was it simply not intuitive? But as I dug deeper, I realized the barrier wasn’t human behavior , it was the toolchain.

Most design systems, code libraries, and layout tools are built on rectangular logic. Even animation frameworks favor linearity. Radial layouts? Curved motion paths? Circular affordances? They often require custom code, creative workarounds, and system overrides.

But things are beginning to shift.

Industry leaders from Apple Vision Pro to Samsung’s Galaxy Watch and even home systems like Google Nest are starting to embrace curved surfaces, rounded edges, and spatial design principles. Circularity is quietly re-entering the design conversation not as a flourish, but as a functional need.

A New Dimension of Micro-interactions

Circular UI unlocks exciting opportunities for sensory-driven design:

• Haptic pulses that follow radial paths
• Microanimations that orbit or ripple outward
• Voice-based interactions that travel around a sound field
• Liquid visuals that breathe, pulse, or stretch dynamically

These patterns invite users into an environment that feels alive, responsive, and non-intrusive — offering a meaningful alternative to flat UI conventions.

Designing for a More Human Future

The future of interface design isn’t about replacing what exists it’s about expanding the language we use to build. Circular UI presents a rich, underutilized dimension of that language. It’s not just about changing shape it’s about changing how people feel while interacting.

As technology becomes more embedded, invisible, and emotionally aware, our design patterns must support more than efficiency. They must support presence, clarity, and trust.

We’ve mastered grids. Now let’s master flow. Circular UI isn’t just about what we design it’s about how we experience. And it’s waiting to be brought to life.

We design in rows, but we live in cycles.
It’s time our interfaces do too. Let’s design for the rhythm of life : circular, fluid, and deeply human.

Why It’s Time to Design Outside the Box — Literally was originally published in Bootcamp on Medium, where people are continuing the conversation by highlighting and responding to this story.