Hand-written personas do not scale

Early persona systems relied heavily on manually authored descriptions:

“Funny, thoughtful, conversational”

“Uses storytelling and examples”

“Warm but direct”

These descriptions helped define a direction, but they created several problems.

Subjective Interpretation

Two people can interpret the same description differently.

“Funny” could mean:

• Dry humor

• Sarcasm

• Playfulness

• Exaggerated jokes

• Observational comedy

The description captured the intention, but not the actual behavior.

Missing Behavioral Boundaries

A persona description often captures someone's strongest traits, but not their boundaries. It may tell us that someone is funny without telling us how often they joke, when they become serious, or what they rarely do.

It does not explain:

• What they rarely do

• What they avoid

• When they become more expressive

• When they become more concise

• When a behavior should not appear

Hard to maintain

As more creators, experts, and personalities are added, manually maintaining each persona becomes expensive.

Every persona requires:

• Writing descriptions.

• Selecting examples.

• Defining behaviors.

• Updating changes.

• Reviewing consistency.

The system needed a way to learn from evidence instead of depending entirely on human interpretation.

How can we compile a persona from evidence?

Instead of asking:

“How should we describe this person?”

We reframed the problem:

"What behavioral patterns can we infer from how this person actually communicates?"

This shifted the persona from a written profile into a compiled representation.

From Persona Writing to Persona Compilation

A traditional persona is authored. A compiled persona is derived.

The compiler collects evidence from conversations, writing samples, creator responses, knowledge sources, and previous interactions, then extracts patterns that describe identity, behavioral tendencies, and concrete examples.

Building the Compilation Pipeline

The compiler works similarly to a programming compiler.

Real conversations contain information that a persona description usually leaves out

A collection of real messages showing when and how someone tells stories is evidence.

The compiler looks for patterns such as:

Communication Style

• sentence length

• vocabulary

• pacing

• formality

• use of examples

• level of detail

Behavioral Patterns

• humor frequency

• emotional reassurance

• directness

• tendency to elaborate

• tendency to ask questions

Conversational rhythm

• short acknowledgements

• unfinished thoughts

• tangents

• callbacks

• moments of emphasis

The goal is not to copy individual messages.

It is to discover repeated behaviors.

A description can define a behavior, but examples show what that behavior actually looks like

Behavioral instructions often become generic.

For example:

“Be supportive”

does not explain:

• How supportive?

• How emotional?

• How direct?

• How long should the response be?

Instead, the compiler extracts examples from the person's own conversations.

User: “I'm nervous about tomorrow”

Creator: “You'll be fine. You've done harder things than this.”

The second gives the model information about:

• length

• emotional intensity

• directness

• reassurance style

• vocabulary

• whether it over-explains

These examples become behavioral references for generation.

Raw examples alone are not enough

The system also extracts higher-level characteristics.

For example:

A creator might consistently show:

• medium energy

• low formality

• high warmth

• occasional humor

• direct explanations

Another creator might show:

• low energy

• high precision

• analytical explanations

• minimal emotional framing

These characteristics don't define a fixed personality script. They define the tendencies through which the shared behavioral system should express that person.

Both personas may have access to the same possible behaviors. The compiled profile determines how those behaviors should typically be expressed.

The compiler needs to show that it learned something rather than simply memorizing the training examples

The system separates:

• Training evidence: Used to compile the persona.

• Held-out evidence: Used only for evaluation.

Training evidence is used to construct the persona.

Held-out evidence is deliberately excluded from compilation and used only to evaluate the result.

This lets us ask a more meaningful question:

Can the compiled persona reproduce the person's communication patterns on examples it has never seen?

People change. A compiled persona can become outdated.

A persona is compiled from evidence available at a particular point in time.

But the creator's communication can change.

They may become:

• more concise

• more formal

• less humorous

• more expressive

• more direct

• more willing to explain through examples

So the system needs to detect when the current creator evidence no longer matches the active persona.

When new creator evidence becomes available, the system can compare recent communication patterns against the active compiled persona.

If the difference exceeds a threshold, it recommends recompilation. Only after that do we compile a new version.

After recompilation, the new version can be compared with the previous version to understand what changed.

A persona is not a description. It is a behavioral model.

A written description captures intent.

Evidence captures reality.

The difference matters because people are often inconsistent in ways that make them feel human.

Examples reveal boundaries better than instructions

The goal is not to tell the AI:

“Be funny”

It is to understand:

“When does this person use humor?”

“When do they avoid humor?”

“What kind of humor fits them?”

Evidence makes personas maintainable

Once persona characteristics are derived from evidence, they can be evaluated, compared across versions, and refreshed when the creator's communication changes.

The biggest shift was changing the unit of work from a persona description to evidence

Instead of asking someone to describe what makes a person recognizable, we could ask what their communication repeatedly demonstrates.

That opened up a different way of designing personas: one that could be compiled, evaluated, compared, and eventually refreshed as the person changed.