zapp2photo - stock.adobe.com
As IT apps and services become increasingly codeless, creating them becomes easier, cheaper and faster. But there's one area that developers shouldn't ever gloss over -- creating effective chatbot scripts.
A chatbot's effectiveness comes down to the quality of its script. After all, the entire point of a chatbot is to create a simple user experience. But when it comes to the words used to achieve that standard, it's a deceptively difficult undertaking.
Here are a few tips to create effective chatbot scripts.
Write a chatbot script as if you were writing code
The rules of application coding are similar to the rules of good chatbot scripting. The same careful planning, smart practices, structured review and teamwork are equally effective in both endeavors.
When developers begin work on an application, the first step is defining that application. A number of questions must be asked:
- What problem are you solving?
- Who are you solving the problem for -- who is the user?
- How does it provide value to the user?
- How does it compare to competing applications -- what makes it special?
- What does a win look like -- what specific functionality will satisfy the user?
Once these questions have strong answers, development can move forward -- either in the form of an app or a chatbot script.
When developers prepare to write code that will become an app, it is common to create a flowchart of the events that occur in the application -- from the beginning of a user's interaction to its conclusion.
The same applies to chatbot script development: creating a flowchart of the conversation -- from the first on-screen prompt to the user's clicking away -- is a powerful tool in crafting a script that is effective, thorough and satisfying to the user. It forces the scriptwriter to consider every meaningful exchange desired as a takeaway, as well as incidental or unanticipated exchanges. A human-chatbot dialog is, after all, a process, just like the successful use of an app or running a workflow.
At this stage, defining the script's content is underway, and the scriptwriter must again think like a developer. A developing application has a flow, and it is usually composed of modules, chunks of carefully isolated functionality.
In a chatbot script, it's basically the same thing: Content is defined as information presented and gathered, and each required chunk of information is part of the flow. But there's more to consider. More often than not, chatbots talk to customers, and that means the bot is more than just a librarian presenting information or a telemarketer reading off questions -- it's a tour guide, orchestrating a customer journey.
In other words, the flow of the script reflects the passage from the customer's need-to-know or need-to-complain to the customer's satisfaction -- learning what they came to learn or successfully remedying their situation.
Finally, while playing developer, scriptwriters should walk through the flowchart with another person, talking through it systematically as development teams do. A certain amount of role-playing tightens up the process as the actual writing begins.
Best practices at the keyboard
When developers sit down to write code, they should employ certain best practices that apply equally to good chatbot scripting:
- Be concise. Don't write 10 lines when two will do.
- Be consistent. Veering from an established theme is pointless and confusing.
- Plan for the unexpected. Make certain that all responses result in coherent replies.
- Allow for context. The flow of data often changes and the same is true of dialogs. An answer might reveal new information that leads to an entirely different follow-up question.
- Vary responses so the chatbot seems, emotionally, like another person.
Varying responses is an essential ingredient of the chatbot experience that most other applications don't share and many developers may overlook. Even though the user probably realizes that the chatbot isn't another human being, it is nevertheless more effective if it seems to be.
Other tips for creating chatbot scripts include using an active voice vs. passive -- it's more human. Also, use emojis -- they add warmth to otherwise emotionally sterile text exchanges. And pace the messaging so bots offer responses at the speed a human would -- including a brief pause before producing response text.
Ready for prime time
There's a final step in a developer's rollout of a new app -- it's called user acceptance testing (UAT) and no developer should skip this step. This is a repeat of the earlier development team role-playing -- only this time it's the chatbot interacting with a typical user. The idea is to let the user run the chatbot through the wringer, testing it for survival in the real world.
The value is this: The UAT will fill in the blanks in scripting that the developer missed. This enables developers to go back and make some changes before rolling it out to the public, thus ensuring satisfied users.
And that's a developer's ultimate definition of success.