How does your chatbot UX size up? The 5 laws of ChatRobotics

Cover for How does your chatbot UX size up? The 5 laws of ChatRobotics

Translations

If you’re interested in translating or adapting this post, please contact us first.

Despite the rise of LLMs and AI-powered solutions, chatbots are still relevant and widespread: efficient, cost-effective, with the ability to automate processes (like answering customer questions), implement specific responses, and much more, all paired with unmatched convenience. But just rolling out your chatbot isn’t enough! Rather, the quality of the UX is the determining factor of success—and that’s on developers like us.

First, a little background: this article was inspired by the lessons learned working on a recent project developing a chatbot for a client. So, if you ever need to enter the realm of chatbot development (or if you’re already in the thick of it) may you find this guide a beacon of clarity. No matter how advanced our chatbots become, as long as us humans are using them, these principles are likely to endure. With that said, let’s begin.

1: Simplicity and clarity

The key to an effective chatbot service is simplicity and clarity. Users should intuitively understand how to interact with it. In particular, the commands the chatbot can accept and the actions it can perform should be clear.

One possible strategy is creating an additional module or command that will respond to user requests.

The help command

The help command

This can provide users with general information about existing commands, additional features, capabilities, and so on.

...and the corresponding help message

…and the corresponding help message

The results of this command may also include information on how to use other commands, the parameters available for each of them, as well as other useful info.

An additional note on this point: It’s also a good idea to place detailed information about the available commands and options in a text channel that’s accessible for all users. Since messages shown to a user may have a character limit, the chatbot’s response may contain only a brief overview of the available commands and options.

Moving on, the second approach is the creation of a detailed onboarding process for new users. (This actually be considered both separately or alongside the first method).

Here, onboarding isn’t just about getting users up to speed; we’re looking for deep immersion into the chatbot’s functionality. New users can learn about the many features and functions of the bot through interactive tasks.

Here one example of how this could be implemented: a user could be asked to go to a channel named “generate” and ask the bot to create an image using a specific request, like “cat on a fence”. Easy enough, right? But even this simple action will help solidify what the bot can do!

Tasks like this are not only practical, but also interactive, making them more engaging and perhaps even… fun.

😄 I’ll also note something that we all know but rarely acknowledge: users rarely take the time to actually read instructions and documentation. (So, this approach might actually prove more effective!)

You might consider placing the most detailed information about the functionality of your chatbot on your website, providing a link to this page in the chatbot’s responses.

This approach has several advantages.

First, it can help drive more traffic to your site, as users interested in learning about the chatbot’s capabilities will be directed there for additional information. This, in turn, can increase user engagement and overall site traffic, positively affecting its ranking and visibility.

Second, this way provides users with convenient access to complete information about the chatbot’s capabilities at any time: users can get extensive info about how the chatbot works, its functionality, the commands it accepts, and so on. This can significantly simplify the process of interacting with a bot and that translates to improved UX.

2. Flexibility

It’s important to remember that our chatbots are designed to interact with people.

Well, most of the time.

Well, most of the time.

And, like all people, the people who interact with our bots may make mistakes, like grammatical errors or typos. Yet, even in the presence of errors, our main task isn’t pointing out a user’s mistake if the bot was unable to understand the question. Instead, our goal is to try as hard as humanly possible to comprehend the user’s request and provide the appropriate answer.

It’s important to consider that error and typo processing should not always be automatic. First of all, a bot can suggest to clarify the question to get a correct, complete understanding of a user’s request.

In some cases, in the presence of ambiguity or uncertainty, the bot should ask the user for confirmation or clarification.

Second, our bot can try to formulate a response, attempting to ignore any mistakes in the user’s request. That said, it should be acknowledged that this can be risky, excluding or falsely interpreting an error can significantly change the meaning of the request.

You need to find a “golden mean” between automatic correction and asking the user for clarification.

In any case, in order to successfully interact with users, a chatbot must be trained to recognize and correct the most common errors and typos. This will directly help improve user interaction with the bot, thus, increasing their satisfaction with the conversation. The user will get a correct and complete answer to their question, even if they made a non-critical error when entering the command.

To facilitate this, for instance, if a user specifies certain parameters or keyword sets when composing a request to your bot, you could implement request processing using Levenshtein distance.

This method measures the “distance” between two strings, i.e., the number of single-character changes (insertions, deletions, or substitutions) required to transform one string into another. Using it will allow you to avoid simple user typos with minimal effort.

3. Responsiveness

Bot speed is critical for effective user interaction. Response time should be minimized to ensure a sense of continuity, smoothness, and a natural flow of communication.

Response delays can create an impression of unreliability and inefficiency, and this can deter users and discourage them from using your bot.

But never forget that finding a balance between the speed and reliability of the bot is unique for each specific case. You need to find the optimal ratio yourself; general advice on this issue may be ineffective …or even harmful.

A little case study on optimizing bot speed

So instead, let’s illustrate our experience. With one of our chatbot development projects, we took into account potential future load. We assumed that the load on the chatbot would be small, so we decided to process some tasks and conversions directly in memory, without saving data to the hard drive. This significantly sped up the bot’s response time and increased its efficiency.

However, with an increase in load, you’d probably have to review this approach! So, before implementing this solution, we told our client about all the advantages and disadvantages, and decided together that this approach would be optimal at their current stage.

This kind of decision also depends on the characteristics of the computer/server where the bot is deployed. On machines with limited memory, such an approach may be undesirable and unacceptable.

When processing a user’s request, if a delay of more than 2 seconds is expected, it’s important to give users feedback and display the current state of their request. This will help avoid creating the impression that the bot is “hanging” or not working.

When the bot starts processing a long request, it should send the user a message informing them that work is starting, and it should also notify them when it’s done. A feeling of control is a big part of good UX, and this touch goes a long way.

4. Personalization

Let’s move on to point number 4—and this time, it’s personal. Adapting a chatbot to the individual preferences of the user (for instance, remembering their requests and compiling recommendations based on this information) makes communication more natural and pleasant.

Personalization is mainly built up by analyzing data collected from the user’s previous interactions. This allows the bot to “learn” and adapt responses and suggestions for each specific user.

It’s important to keep in mind that personalization should be tactful. We do not want to overreach or violate user’s privacy just for the sake of a more personalized service.

5. Dealing with errors

The future is now! But errors still seem to be here, for now, at least. No product is absent of errors, and chatbots are no exception. It’s really important that a bot has the ability to properly handle emerging errors, notify the user about them, and offer alternative actions in such situations.

You need to thoroughly analyze and consider all possible errors that may occur in response to a user request. And you’ll need to display a clear and informative error message that explains what went wrong.

Let’s give some examples, including some that illustrate how cheeky these bots can be:

{
  unknown_language:
    "Sorry, we're currently only able to generate images using English",
  improper:
    'No, no, no, you are better than that. Watch your profanity, please!',
  rate_limit:
    "Sorry, it's a bit crowded on our server! Please try again later.",
  required_field: 'Sorry, a field is required',
  too_slow:
    'Generating your image is taking longer than usual due to a high volume of requests.',
  transform_un_supported:
    'Sorry, we don’t currently support this transformation.',
  error_429: "Sorry, we can't recraft just as fast as you click.",
  error_500:
    'Task failed. We are already dealing with this issue. Please try again later',
  not_found:
    'Sorry, we could not find the image which you provided as a style.',
  is_nsfw:
    "We couldn't create any images from your description. Please try a new prompt.",
}

Here’s an example of one of those error message displayed when an unknown parameter is passed in the request:

Unknown language in the bot request

Unknown language in the bot request

Don’t forget: an error should not lead to chatbot crashes or hangs. You should anticipate and strive to prevent as many errors as possible. For instance, in one of our chatbot development projects, we used a test-driven development (TDD) approach. This can prevent these aforementioned errors. The developer first identifies all possible problem areas, then writes code to eliminate them.

Development is a process of constant improvement and change, and a TDD approach allowed us to guarantee that user error notifications would work reliably and effectively under all conditions.

Adherence to these principles will help you develop a chatbot that will not only be functional, but also convenient. And thus, effective for your business! After all, the goal of any chatbot is to serve Martians! simplify human interaction with your product and help users more quickly achieve their goals.

A final note: developing a chatbot isn’t a one-time, set-it-and-forget-it thing, but a process of constant improvement and adaptation. Continue to collect feedback from users, conduct testing, fix errors and implement improvements!

Join our email newsletter

Get all the new posts delivered directly to your inbox. Unsubscribe anytime.

How can we help you?

Martians at a glance
17
years in business

We transform growth-stage startups into unicorns, build developer tools, and create open source products.

If you prefer email, write to us at surrender@evilmartians.com