Design challenges for AI co-created tools
AI co-created tools introduce a lot of design challenges. We don't need all the answers, but we'll need space to iterate.
THIS IS A DRAFT POST – Please subscribe to get a notification when its done.
See this earlier post for context:
When to change UIs, when to keep them the same?
Familiar UX patterns are good and should be reused. How do new ones evolve?
The more complex a UI is, for a good reason – i.e. it's worth learning it, the less desirable are magical changes. But we already see long menus being challenged by in-app natural language interfaces.
How does navigation work?
Does "app level" and "contextual system level" merge?
How do back buttons, undo and redo map to this, including modifications to the tools themselves?
How does feature discovery work if there are in principle infinitely many features?
Are navigation elements just zero-shot suggestions? Is there an opportunity for social cues, e.g. showing what in aggregate others in this context typically do?
Can AI prompt for next steps in generative ways? Speculatively executing a few steps down and pulling some possible directions up (Speculative execution is enabled by the runtime ensuring the lack of side effects!)? Not just for better efficiency, but guiding towards what is meaningful to the user or the participants in a shared space!
How do collaborative experiences feel?
What part of the UX is shared vs not? How do I e.g. know that drafting a message is private? Can I take something "offline", edit on the side and then bring it back (see this recent exploration by Ink & Switch)
How does changing the tools on-the-fly work when there are multiple users in them? Can they fork their own versions?
How does control over one's data work and how participation in governance?
Delegation to trusted parties plays a key part, and some of those trusted parties might ask users to be engaged in collective governance.
UX – including natural language – to understand why something happened (or not happened) and the ability to evolve guardrails.
Transparency as a key trust mechanism. Even if one would rarely dig into the depths of it, the fact that everyone has those transparency tools and that somewhere someone does use them and can effectively flag problems is another trust mechanism. Can we somehow visualize that collective verifying?
Attribution – Who is responsible for errors, who to ask for help?
AIs will get it wrong, but sometimes also the human or the company will screw up.
How to figure out which is which, make sure companies and their humans aren't overwhelmed with false reports, or worse lose trust, while also now allowing "must be the AI that got it wrong" as lame excuse.
Some components are more trustworthy than others (e.g. Wolfram Alpha vs the LLM doing math), how can that be represented? Something like the least reliable part of a chain?
If users are prompted to verify things themselves, can we signal the need for that with UI. Maybe a checkbox that confirms that one did verify something, which would be useful for later aggregation steps that collate earlier information into something publishable?
How does system-level navigation work, how is my data organized?
New tasks vs long running tasks – instantiated tools – that users can come back to
Inboxes that are different views on the same, or at least overlapping data? Do they replace notifications, i.e. do requests to interrupt a user route through these tools?
Different tools for different types of data, for finding and organizing. Relationships and system-wide timeline might be key backbones.
New tools are remixes of close matches, rarely created from whole cloth. And with that can come certain base expectations about how they work, e.g. in collaborative settings.
Of course, there are still baseline notions like quick access to regular tasks, recents and a global free form natural language entry point.