Traditionally, users have interacted with software through either graphical/terminal interfaces or programmer APIs. However, we could argue that even after incredible effort invested in understanding the way users interact with UI elements and on improving workflows to make them more friendly and intuitive, many users continue to struggle when trying to accomplish tasks with software applications.
The emergence of widely available Large Language Models (LLMs) open the doors for a new approach based on the use of natural language, and in this article, I present an easy leverage this technology to automate complex tasks and transform the user experience.
The GUI and the Use Case Barrier
For decades, UI/UX design has been driven by the use case approach—designing interfaces based on anticipated user goals and workflows. While some designs emerge from rigorous user studies and iterative feedback, in others it is just the result of a guessing game where the programmer assumes the way users will interact with the software.
The use cases approach is obviously limited by definition given that users can only perform actions the developers have anticipated and specifically implemented, constraining usability but especially all predicted use of the application power.
The Programming Knowledge Barrier
While APIs offer programmatic access to software functionality, enabling integration, automation, and advanced queries beyond the GUI, they require programming expertise. This technical barrier effectively restricts API utilization to a small subset of users with development skills, leaving most users unable to access these powerful capabilities.
Overcoming limitations
LLMs break down these barriers by interpreting natural language commands regardless of the user's native language, grammatical accuracy, or typographical errors. This enables a new level of accessibility, allowing users to express their intent conversationally rather than learning specific UI patterns or programming languages.
Consider a Bitcoin wallet scenario where a user could simply type
"Send all coins under 3 dollars to Wasabi's donations address"
and have the action executed immediately—no menus, buttons, or code required. But how exactly could a LLM interact with the user's bitcoin wallet software to do that?
The Code Generation Bridge
One of the most useful things Large Language Models can do is to generate code and that means that it can generate something that can do something. In the context of this article it means that if the application internal modules' API is known, it can generate code that interacts with your software to achieve a whatever it is possible to do.
Experimenting with Wasabi Wallet
To fully harness AI capabilities, software applications must provide a programmatic interface that LLMs can utilize—ideally through an embedded scripting language.
Scheme: An AI-enabler Scripting Layer
Wasabi Wallet can understand a subset of Scheme language and then it can execute programs written by humans and/or AI. For example, here you can see an example of how the Claude 3.7 Sonnet translated a similar command to the one above in Scheme language understandable by Wasabi Wallet.
This is awesome because it allows users to perform actions that we developers could have never imagined, and the only thing the AI needed was a one-line prompt previously injected with something like the following:
### Fetching information
While most Bitcoin wallet applications try to improve the user experience by hiding as much information as possible, those wallets are terrible for privacy because information is what makes decision making possible. These wallets are, generally speaking, mobile wallets.
More advanced wallets on the other hand try to present the users as much information, and options, as possible to allow them precisely to decide what they want to do and evaluate the available alternatives. These wallets are all desktop wallets.
While the former are newbie-friendly for their simplicity, the latest tend to have over-bloated UI. Wasabi tried to be somewhere in the middle by simplifying the UI as much as possible while allowing the users to see more and get more options in a feedback loop.
Beyond UI Limitations: Complex Queries
Traditional interfaces struggle with complex, multi-criteria queries. For example, consider this scenario: you need to send funds to an exchange and must identify coins that aren't from coinjoins, are already known to exchanges, and were received over a year ago—a task virtually impossible with conventional wallet interfaces.
Again, no wallet can answer these kind of questions.
Why Scheme Language
In Wasabi, we cannot add more dependencies. That means that whatever language we want to use must be already available, or the interpreter must be developed from scratch. The language must be extremely simple and immutable to prevent accessing Wasabi internal functionality other than the explicitly provided by the devs. The language must be known in order to be understood by LLMs.
Scheme is the language that satisfies these requirements because it has almost no syntax and it looks like you are writing the the abstract syntax tree by hand, the initial version of the interpreter is tiny and easy to maintain (about 600LoC), it is mostly immutable and the 'set!' special form cannot escape to the .net code and it is old enough to be very well understood by LLMs.