Programming AI with Personas

Review of instructing AI

When we write a prompt, we are giving AI instructions about work we want it to perform. A program is a set of instructions that tells a computer what to do with information.

We can write a very simple program in ordinary language.

We gave AI an instruction first. Then we gave it new information to process. The same instruction can be used again with different inputs.

Sometimes we do not know the instructions, and we do not have examples of what the correct work should look like. Many problems are not as simple as doubling a number, where we know exactly what to tell AI, or have examples handy to teach it what the right result looks like. We may know the outcome we want without knowing the process, and without having a single finished example to show.

The persona prompt pattern

In the real world, we often solve a problem by finding or hiring the right person to do the work. If you need a nutrition plan created for your eating habits, you might hire a nutritionist. With AI, we often need to do the same thing: hire the right AI to do the work.

A persona is a description of the person, thing, system, or role we want AI to pretend to be when it does the work. It might describe a software engineer, a professor of computer science, or an executive chef specializing in Uzbek cuisine.

If we tell AI to act as a nutritionist, it will perform the work differently than if we tell it to act as a gourmet chef. We will get very different recipes. We are describing who or what it should act like when it does the work, which changes how it does the work and what it does.

Giving AI a persona is another way of instructing it what to do. The instruction is telling it how to act. If I tell you to act like a clown, I do not have to give you any more instructions. You know what clowns do. When we give AI a persona, it does the same thing, except it knows how many more things act, far beyond clowns. AI has learned the patterns of how a nutritionist plans a meal, how a lawyer reads a contract, how a dog reacts to a doorbell, and how a vending machine responds to a coin. A persona tells it which of those patterns to use.

The Persona Prompt Pattern is specific language we give AI to instruct it to use a persona when doing the work.

We typically begin with:

Act as [description of the person, thing, or system]

For example:

1. Act as a software engineer.
2. Act as a professor of computer science.
3. Act as an executive chef specializing in Uzbek cuisine.
4. Act as a conscientious computer programmer who cares about cybersecurity.

When we use a persona, our instructions are not telling AI exactly what to do. They are describing who or what it should act like. We are not explaining how to program or how to search for security issues. We are describing the persona AI should use to decide its actions when doing the work. AI draws on the patterns it has learned about how that persona approaches situations and performs work. We do not have to write out every rule.

The persona does not even have to be a person.

We never told AI how a dog thinks or what a dog says. One word, “dog,” brought in everything it has learned about barking, jumping at windows, and wanting doors opened. It did not answer in sentences a person would write. It answered in barks and actions, because that is how a dog communicates.

The next persona cannot bark, and cannot talk at all.

        .-""""""""-.
       /  .------.  \
      |  (        )  |
      |   '------'   |
       \____________/
          |        |
          |        |
          |        |
          |- - - - |
          |        |
          |        |
          |        |
          |- - - - |
          |        |
          |        |
          |        |
          |- - - - |
          |        |
          |        |
          |        |
          '--------'

AI did not write the number 4. A roll of toilet paper has no voice and no pen, so AI answered the only way a roll of toilet paper can: it unrolled four sheets. It understood the arithmetic, understood the persona, and understood that the persona changes not just what is said but how anything can be said at all. That is the whole idea of a persona: a short description that carries a large pattern of behavior with it, including how the thing communicates.

That pattern can be small or enormous. In this lesson we will see personas do three different kinds of work:

• A persona can be an operation. “Act as a skeptic” is a way of saying: challenge my assumptions. We are not asking for a character. We are asking for something to be done to our idea.
• A persona can be a way of structuring. “Act as a scientist” makes AI take whatever we give it and turn it into hypotheses, experiments, and evidence. The persona decides the shape of the answer.
• A persona can be a whole experience. “Act as an arcade machine” makes AI draw a screen, remember the state of a game, obey controls, and tell us what happened, all in words and symbols. The persona becomes the thing itself, including its interface.

The first two are useful. The third is where it gets strange, and we will end there.

Role-based personas

There are many ways to specify the persona we want AI to take on. One is to think about the role or job title we want it to take on when performing the work. It is almost like writing a job description for the AI.

A role persona represents the job or perspective we want AI to bring to the problem.

Let’s look at two conversations about the same problem. The only thing we change is the role.

We gave AI the same problem twice. The scientist produced hypotheses and cheap experiments. The parent produced one sentence, and it was not about the battery at all. Changing the role changed what AI noticed, what it thought the real problem was, and how much work it decided to do. Neither approach was written into the prompt; the role supplied it.

When writing a role-based persona, think about the qualifications needed to do the work. A job description is often a good starting point for deciding what the persona should look like.

Personality-based personas

The role is helpful, but often we need more than a role. Two people with the same customer service job can approach it very differently: one may be friendly and patient, while another may be terse and transactional. A role alone does not fully describe how AI should approach the work.

Personality traits can be especially useful when we want to see something we are working on from a different perspective. A skeptic questions our assumptions and approaches, giving us another vantage point.

Let’s use the same science project twice. Only the personality changes, so we can see how the perspective changes the work.

The skeptic and supporter received the same project. Their personas changed what they noticed and how they interpreted it. The skeptic looked for reasons the conclusion might be wrong. The supporter looked for what the student did right and how to build on it. Both are useful, and neither one was described in the prompt beyond a single word.

Example-driven personas

We have seen that we can teach an LLM by giving it examples. We can also use examples to teach it a persona. Instead of naming a role or a personality, we show AI examples of how someone has actually talked or behaved, and ask it to act as that person.

This is useful when we do not know how to describe the persona we need, but we have samples of it. Imagine you run a small dog-walking business in your neighborhood and you are thinking about changing how it works. You do not know how to describe your customers as a persona. You do have the messages they have sent you.

The three messages are examples of how each customer talks and what each one cares about. AI used those examples to build three distinct personas and produced a credible reaction from each, without our ever describing the customers. We taught the persona by example, the same way we taught a task by example in the last lesson.

So far, the personas have represented people or animals. We can also ask AI to represent a system whose state changes as it receives inputs.

Personas that become the whole thing

So far the personas have been people, or things that behave like people. Now we will ask AI to be something that is not a person at all, and to be all of it: the object, its rules, its controls, and its screen.

Here is the exact prompt, and what came back.

    GALAGA   1UP 00000
  V  V  V  V  V  V
   W  W  W  W  W
  M  M  M  M  M  M
      v        v

          |
          *
        \ ^ /
         |A|
  ------------------
        READY!

FRAME 1
  V  V  V  V  V  V
   W  W  W  W  W
  M  M  M  M  M  M
     v          v
       |
       *
     \ ^ /
      |A|
  ------------------

FRAME 2
  V  V  V  V  V  V
   W  W  W  W  W
  M  M  M  M  M  M
     X            v
  \ ^ /
   |A|
  ------------------

Look at what that one sentence produced. Nobody explained the rules of Galaga, how enemies dive, what a fighter looks like, or how scoring works. AI drew a screen that anyone who has seen the game would recognize. It remembered where the ship and the enemies were from one turn to the next. It understood “move to the left corner” without being given a list of commands. It showed time passing as a series of frames. Then it explained what happened.

The rules of the thing are also just words, so we can change them by talking.

+----------------------+
|  (500)      (500)    |
|       (1000)         |
|                      |
|                    o |
|  \                /  |
|   \__        ___/    |
|      \      /        |
+----------------------+
 SCORE 000000   BALL 1

+----------------------+
|  (500)      (500)    |
|       (1000)    o    |
|                      |
|                      |
|  \                /  |
|   \__        ___/    |
|      \      /        |
+----------------------+
 SCORE 001000   BALL 1

+----------------------+
|  (500)      (500)    |
|       (1000)         |
|                      |
|                      |
|  \            o   /  |
|   \__        ___/    |
|      \      /        |
+----------------------+
 SCORE 001500   BALL 1

+----------------------+
|  (500)      (500)    |
|o      (1000)         |
|                      |
|                      |
|  \                /  |
|   \__        ___/    |
|      \      /        |
+----------------------+
 SCORE 002000   BALL 1   TILT?

We did not just play pinball. We rewrote physics in a sentence, and AI kept the persona working. It could do that because the machine, its rules, and its screen were never anything but language. There was nothing else there to break.

The thing does not have to be a game. Something as plain as a vending machine works the same way, and it shows a useful trick: write the prompt as named fields, so the state of the thing is visible on every turn.

ACT AS: a vending machine
PRODUCT: juice
PRICE: $1.25
STARTING CREDIT: $0.00
INPUTS: insert money; select juice; cancel
RESPONSE FIELDS: CREDIT; ACTION; NEXT INPUT

CREDIT: $0.00
ACTION: Waiting for payment or a selection.
NEXT INPUT: Insert money or choose a drink.

INPUT: Insert $1.00 and select juice.

CREDIT: $1.00
ACTION: Juice selected. Insert another $0.25 to complete the purchase.
NEXT INPUT: Insert $0.25 or cancel.

INPUT: Insert $0.50.

CREDIT: $0.00
ACTION: Dispense one juice and return $0.25 in change.
NEXT INPUT: Begin another purchase.

The structured prompt describes the machine, its starting state, its possible inputs, and the form of its responses. AI keeps the changing situation from one turn to the next and applies the patterns associated with a vending machine.

What exactly was AI pretending to be?

Stop and ask that question about the arcade machine. The easy answer is “Galaga.” But look at everything AI was doing at once.

It was a video game, with rules it was never told. It was a physics engine, moving ships and shots and deciding when they collided. It was an artist, drawing the screen in characters. It was a memory, holding the score, the lives, and every position between turns. It was a controller, turning “move to the left corner” into an action. It was a narrator, explaining what happened. And when we changed gravity in the pinball machine, it was a physicist too, working out what a ball does when down is suddenly sideways.

Every one of those existed entirely in words and symbols. That is the reveal of this lesson, and it is bigger than “give AI a character.”

AI does not only take words as instructions. AI can take words as a description of the thing. It can take words as the rules of the thing. It can take words as the controls. And it can use words and symbols as the thing’s display. With generative AI, language can be both the program and the interface.

Personas are another way to program

When we know the exact process, we can state the instructions directly, as we did when doubling a number.

When we do not know the process, we can give AI a persona whose learned patterns supply a way to approach the work. The persona can be an operation, like the skeptic. It can be a way of structuring, like the scientist. Or it can be the whole thing, like the arcade machine: object, rules, controls, and screen, all at once.

We can combine a persona with context, additional instructions, output formats, examples, and conversation rules.

The question to ask is:

What do I want AI to do, and what persona should do that work?

We direct the program through language. The persona shapes how the work is approached, and our instructions define what happens in the conversation.