jev gives you a number for how unsure it is. that's a design tool.
most ai interfaces show you one confident answer. typesafe's jev returns a confidence score instead, and that single number changes what you can design. a short read for designers.
jev launched last week. it isn't a chatbot: you hand it some state, ask a typed question, and it returns a decision your code can use. pick one of these options. rate this against a rubric. yes or no.
the part worth a designer's attention is smaller than the launch post: every answer comes back with a confidence score.
that sounds like a backend detail. it isn't.
the problem with every ai feature you've designed
almost every ai interface shipping today presents one answer, confidently, with no indication of how sure the system is.
so you end up designing one of two screens. either the model is treated as right and the user finds out later that it wasn't, or you bolt on an "are you sure?" dialog that appears every single time and gets clicked through without reading within a week.
neither is good. both exist because the model gave you a string and no way to know if it was a guess.
a confidence score removes that constraint. you're no longer designing one state. you're designing three.
the three states
above ~90%
act
apply it. no dialog, no confirmation. just make it undoable.
~60 to 90%
suggest
pre-fill it and let them correct it. this band is where the design work is.
below ~60%
ask
do not guess. show the options and let a human pick.
that middle band is the whole opportunity. it's the state most ai features never design for, because without a confidence number you can't detect it. it's also where the majority of real answers live.
what this looks like in practice
say you're designing ticket triage.
without confidence: every ticket gets auto-tagged. some tags are wrong. support stops trusting the tags. six months later someone turns the feature off.
with confidence: clear-cut tickets get tagged silently. ambiguous ones arrive pre-filled with the top guess and a one-tap correction. genuinely unclear ones land in a small queue that a human clears in two minutes a day.
same model, same accuracy. completely different product, because the interface stopped pretending it knew.
the correction taps are a bonus: they're labeled training data, generated by the people best placed to label it, as a side effect of doing their job.
two things to get right
don't show the percentage to users. "54% confident" means nothing to someone triaging a ticket, and it makes your product look unsure of itself. the number is for your branching logic, not your interface. the user should see a different treatment, not a different number.
pick your thresholds from real data, not vibes. run a few hundred real items through, look at where the model is actually wrong, and set the cut-offs there. the 90/60 above are a starting shape, not a recommendation.
the caveat
one finding from the independent testing is worth carrying: renaming the options changed about a third of jev's answers. not the input, the option labels.
which means your microcopy is part of the logic now. if you rename urgent to high priority in a tidy-up pass, you may have changed what the system decides, and no test will catch it.
that's a genuinely new thing to hold as a designer. copy near an ai decision is closer to production code than to content.
worth trying?
jev's signups were paused when i wrote this, so possibly not this week. but the pattern doesn't depend on jev at all. any model that returns a probability lets you design the three states, and most of them can be coaxed into it.
the useful idea is just this: stop designing for one answer. the uncertain middle is where your interface earns its keep, and you can only design for it once something tells you it's there.