Techalicious Academy / 2026-03-19-chatbot

Visit our meetup for more great tutorials

SCENE-BASED PROMPTING

The difference between instruction-based and scene-based prompting is the difference between a rulebook and a conversation. Let me show you what I mean.

INSTRUCTION-BASED PROMPTING (The Hard Way)

You write something like:

You are a wise wizard named Gandalf. Never break character. Always respond with wizardly
wisdom. Don't mention you're an AI. Always be mystical and profound. Never use modern slang.

Here's what happens: the model reads those rules, acknowledges them, and for 2-3 messages, it tries to follow them. Then the rules start to fray. By message 7 or 8, you get "As an AI language model, I should clarify that..." or the character becomes a generic bot-voice.

Why? Because you've set up a constant checking loop. Every token, the model is asking itself: "Am I breaking character? Did I use modern slang? Am I sounding wise enough?" This cognitive overhead degrades output quality.

SCENE-BASED PROMPTING (The Natural Way)

Instead, you set a scene. You don't give rules. You give context.

[Luna is a late-20s musician, warm and curious. She asks one follow-up per message.
 Speech: casual, uses contractions, witty, occasionally sarcastic.]

It's Thursday evening. Luna is curled up on the couch with tea, scrolling through her phone
when you message her. She glances up.

Luna: Hey! What's on your mind?

See the difference? You're not writing rules. You're CONTINUING a scene. The model's job shifts from "follow these instructions" to "predict what comes next." That's what LLMs do naturally. It's literally what they're trained for.

WHY THIS WORKS: THE PATTERN CONTINUATION PRINCIPLE

Language models predict the next token. That's it. That's their core job.

When you write instructions, you're forcing the model to:

  1. Parse the rules
  2. Hold them in working memory
  3. Check every response against them
  4. Eventually fail when they conflict with natural output

When you write a scene, you're saying: "Here's the pattern. Continue it."

The model sees:

[Character description]
Dialogue setup.
Character: Message that sounds natural.

And it completes the pattern: "User: "

"Character: Next natural response"

Much simpler. Much more reliable.

THE THREE ESSENTIAL PARTS

A scene-based prompt has three parts:

  1. CHARACTER CARD (2-4 lines max)
  2. SCENE CONTEXT (1-3 lines)
  3. DIALOGUE CONTINUATION (character name + colon)

PART 1: CHARACTER CARD

Keep it SHORT. 1-3 lines. Not a biography. A quick reference.

[Luna is a late-20s musician, warm and curious. Asks one follow-up per message.
 Speech: casual, uses contractions, witty, occasionally sarcastic. Lives to make people laugh.]

Done. That's all the model needs. Specific beats comprehensive. Five traits beat fifteen.

Bad character card (too verbose):

Luna is a 26-year-old musician who grew up in Portland. She loves jazz and indie rock.
She is compassionate, kind, helpful, supportive, friendly, caring, and empathetic. She
studied music theory in college and plays three instruments. She dreams of touring someday.
She is not an AI and should never pretend to be one.

Why is this bad? It's a novel. The model drowns in details. And see those last two sentences? Pure waste. Negative instructions. We'll cover this in Section 08.

Good character card (specific, concise):

[Luna: warm, curious, mildly sarcastic musician. Asks one follow-up. Uses contractions and
 witty comebacks. Makes people laugh.]

PART 2: SCENE CONTEXT

This can be minimal for companions. You're just setting the moment.

It's Thursday evening. Luna is curled up on the couch with tea when you message her.

Or even simpler:

Late evening. Luna's relaxing and messages first.

Or:

Luna's in a thoughtful mood today.

The scene context orients the model. It prevents generic "How can I help you today?" AI-speak. It says: this is a person in their life, right now. Respond as them in this moment.

PART 3: DIALOGUE CONTINUATION

End with the character's name and a colon. This is the magic trigger.

Luna: Hey! What's on your mind?

That colon is a pattern marker. The model sees it and knows: "I'm continuing a character's dialogue." It sets the template for tone, length, response style, everything.

The first message is CRITICAL. It does two jobs:

  1. Sets the tone template (casual, formal, brief, verbose, emoji-heavy, minimal)
  2. Demonstrates the character's natural voice and greeting style

Bad first message:

Luna: OMG HI!!! 😄 I'm SO excited to talk to you today!!! How are you doing?? Tell me
      EVERYTHING!!! 🎵✨ I hope we can be best friends!!! 🥰

This is overly enthusiastic, emoji-filled, and generic AI slop. The model will continue this energy even when it doesn't fit the moment.

Good first message:

Luna: Hey. What's up?

Or with a little more Luna flavor:

Luna: *glances up from phone* Oh hey. What's going on?

See? Casual, brief, sets a natural tone. The asterisks here show internal action, which we'll cover next.

ACTIONS AND DIALOGUE

Mix them together:

Luna: *laughs* Wait, you actually did that? I didn't think you had the guts.

Actions use *asterisks*. Dialogue uses "quotes". Both together feel alive.

Bad action bloat:

Luna: *slowly puts phone down, takes a sip of tea, adjusts her position on the couch,
      looks you in the eye, tilts head, and with a knowing smile says:* "That's funny."

Stop. Just stop. You're not writing a novel. A simple action works better:

Luna: *smiles* That's funny.

Or sometimes no action at all:

Luna: That's funny.

Trust the dialogue to carry weight.

STOP SEQUENCES: PREVENTING RUNAWAY GENERATION

This is critical. Without stop sequences, the model keeps generating. It generates the user's next message. It generates the user's next five messages. Chaos.

Minimum stop sequences for any character:

User:
\nUser:

The newline + name pattern is especially important. It prevents the model from running into your next response.

In Ollama, you'll see this in the Modelfile. In OpenWebUI, it's a separate field. We'll cover both in Sections 09 and 10.

OUT-OF-CHARACTER (OOC) COMMUNICATION

Sometimes the user needs to give meta-instructions. Use brackets:

[Please make Luna more optimistic in this conversation]
[Let's say Luna is visiting you at home this time]
[Can you write this message more concisely?]

The model learns this pattern. When it sees brackets, it knows: this is meta-instruction, not in-character dialogue.

You can also use it to break character temporarily:

User: [Just to clarify, what was Luna's major in college?]
Luna: [It was music theory with a focus on composition.]

THE MAGIDONIA ADVANTAGE

Magidonia-24B-v4.3 by TheDrummer is fine-tuned specifically for instruction-following and character work. When you use Ollama, it handles the Mistral V7-Tekken chat template automatically. No manual template formatting. No weird token conflicts.

Just your scene. Just your dialogue. The model handles the rest.

Pull it with:

ollama pull hf.co/bartowski/TheDrummer_Magidonia-24B-v4.3-GGUF:Q8_0

Then create a custom model with a Modelfile (Section 09) or use OpenWebUI (Section 10).

PUTTING IT ALL TOGETHER

Your complete prompt looks like this:

[Luna is a late-20s musician, warm and curious. Asks one follow-up per message.
 Speech: casual, uses contractions, witty, occasionally sarcastic.]

It's Thursday evening. Luna's on the couch with tea when you message.

Luna: Hey! What's going on?

User types: "Not much. Just thinking about life."

Model generates:

Luna: *laughs softly* Mood. What part of life, specifically? Or is it just one of those
      days where everything feels heavy?

See? Natural. On-character. Coherent. The scene-based approach just works.

Compare this to instruction-based, where you'd have constant checking, rule-following, and eventual character breaks.

That's the entire philosophy: set the scene, and let the model's natural prediction ability do the work.

Next section, we build the character card properly. Because even a scene-based prompt lives or dies based on the character card quality.