When was the last time you designed a screen that said "maybe"?

Most of us haven't. We've spent our careers in a world of binary states — success or error, on or off, loaded or loading. But AI doesn't think in binaries. It deals in probabilities. And if we keep designing as though its outputs are gospel, we're going to build some dangerously overconfident products.

What's actually happening

A concept called Probabilistic Design is gaining traction in UX circles right now. The core idea: stop treating AI-generated predictions, recommendations, and decisions as definitive answers. Start designing interfaces that communicate confidence levels, likelihoods, and uncertainty honestly.

It sounds obvious when you say it out loud. But look at how most AI features ship today — a recommendation engine that says "You'll love this," a scheduling tool that declares "The best time is Tuesday at 2pm," a writing assistant that simply replaces your sentence with its version. No hedging. No confidence indicators. No acknowledgement that the model could be wrong.

That's a design problem, not a technical one.

Why this should worry you

Here's the thing: AI is quietly moving from "feature" to "infrastructure." It's not just powering chatbots and image generators — it's increasingly informing the logic behind layouts, content decisions, personalisation, and accessibility recommendations.

When a model tells your product that a user probably wants X, your UI presents X as fact. The user has no way to know that "probably" was doing all the heavy lifting in that sentence.

I'd call this false certainty — interfaces that look authoritative but are built on shifting sand. And it's a trap we're uniquely positioned to fix.

Think about it. We already know how to communicate states. We use colour, typography, hierarchy, and motion to tell users what's happening, what's important, and what needs attention. Communicating confidence is just another layer of that same skill.

Some practical examples:

  • A recommendation that says "Based on your history, you might enjoy this" rather than "Recommended for you"
  • A predictive scheduling tool that shows a range of likely times rather than a single "optimal" slot
  • A content suggestion with a subtle confidence indicator — even something as simple as "high confidence" vs. "experimental"

These aren't dramatic redesigns. They're small acts of honesty.

Doesn't better context fix this?

There's a related development worth noting. Atlassian recently shared how one of their teams shifted from treating AI as a generic tool to giving it persistent, ongoing context about their workflows and goals — a practice increasingly called context engineering. The results were dramatic: AI usage spiked massively once the tool actually understood their specific environment.

And this is important — better context does make AI more useful and more accurate. But it doesn't make it certain. Even the best-fed model is still probabilistic at its core. Context engineering reduces the margin of error. It doesn't eliminate it.

So we need both. Give your AI better context and design your interfaces to communicate that uncertainty still exists. These aren't competing ideas. They're complementary.

Tool spotlight: confidence indicators as a design pattern

This isn't a single tool to download — it's a pattern to adopt. Start experimenting with confidence indicators in any interface where AI informs the output.

This could be as lightweight as:

  • A text label ("Suggested" vs. "Confirmed")
  • A visual scale — think progress bar, but for certainty
  • Contextual tooltips that explain why the AI is recommending something
  • Colour coding that distinguishes high-confidence outputs from speculative ones

Who's this for? Anyone designing product features that surface AI-generated recommendations, predictions, or decisions. If your product uses a model to make suggestions, your users deserve to know how much weight to give them.

The beauty of this pattern is that it doesn't require engineering changes to the model itself. It's a presentation layer decision — which means it's squarely in our territory as designers.

So what should you actually do?

Pick one screen in your current project where AI informs the output. Ask yourself: does this UI communicate certainty that the underlying model doesn't actually have?

If the answer is yes — and it probably is — you've found your next design improvement.

Uncertainty isn't a bug to hide. It's information your users need. And designing for "probably" isn't a step backwards — it's the kind of honest, considered work that separates thoughtful design from feature-shipping on autopilot.