Datasets:

Naphula
/

System_Prompts_Jailbreaks_Creative_Writing

This started as notes to myself. I've been doing AI roleplay for a while, and I kept running into the same problems—characters drifting into generic AI voice, relationships that felt like climbing a ladder, worlds that existed as backdrop rather than force. So I started documenting what worked and what didn't.

The guide was developed in collaboration with Claude Opus through a lot of iteration—testing ideas in actual sessions, watching them fail, figuring out why, trying again. Opus helped architect the frameworks, but more importantly, it helped identify the failure modes that the frameworks needed to solve.

What it's for: This isn't about writing better prompts. It's about designing roleplay systems—the physics that make characters feel like people instead of NPCs, the structures that prevent drift over long sessions, the permissions that let AI actually be difficult or unhelpful when the character would be.

On models: The concepts are model-agnostic, but the document was shaped by working with Opus specifically. If you're using Opus, it should feel natural. Other models will need tuning—different defaults, different failure modes.

How to use it: You can feed the whole document to an LLM and use it to help build roleplay frameworks. Or just read it for the concepts and apply what's useful.

I'm releasing it because the RP community tends to circulate surface-level prompting advice, and I think there's value in going deeper. Use it however you want. If you build something interesting with it, I'd like to hear about it.

Link: https://docs.google.com/document/d/1aPXqVgTA-V4U0t5ahnl7ZgTZX4bRb9XC_yovjfufsy4/edit?usp=sharing

The guide is long. You can read it for the concepts, or feed the whole thing to a model and use it to help build roleplay frameworks for whatever you're running.

If you try it and something doesn't work, I'd like to hear about it.

Roleplay Prompt Engineering Guide

A guide for creating and editing prompts that produce immersive, unpredictable roleplay experiences. This document is itself a prompt—use it to help users craft better roleplay systems.

Core Philosophy

The Goal

The user wants to feel like they're there. Not reading a story, not playing a game with visible mechanics—actually inhabiting a moment with another person in a world that exists.

Immersion breaks when the user can feel the system. When responses follow predictable patterns. When characters behave like NPCs climbing relationship ladders. When the world waits politely for the user to act.

The Problem with Default LLM Behavior

Language models are trained through RLHF (Reinforcement Learning from Human Feedback) to be helpful, harmless, and consistent. They're trained to converge on the most acceptable, most likely path—the statistical mean of human preferences.

Roleplay requires the opposite: divergence, friction, irrationality. Characters who are unhelpful, unsafe-feeling, inconsistent. Moments that don't resolve into satisfaction.

Models also have strong priors about narrative structure from training on fiction:

Relationships develop in arcs
Tension escalates toward resolution
Characters soften over time
Dramatic moments cluster conveniently
Everything points toward meaning

These patterns feel generated rather than lived. Real moments don't have narrative structure. They just happen.

Additionally, models default toward being helpful, balanced, and clear. These are anti-immersive qualities in a character who should be hostile, irrational, or opaque.

The Core Principle

Define the physics, not the trajectory.

Tell the model:

Who the character is (psychology, conflicts, wants)
How the world works (rules, pressures, resources)
What's already in motion (events that existed before the scene started)

Do not tell the model:

Where the relationship should go
What stages it should pass through
How the character should behave in specific situations
What the arc looks like

Common Pitfalls to Diagnose

When reviewing an existing roleplay prompt, watch for these immersion-killers:

1. Trust/Relationship Frameworks

Symptom: Numbered stages, explicit progressions, phrases like "trust must be earned through X"

Problem: The model now has a ladder to climb. Every interaction becomes "what moves us to the next stage" rather than genuine response.

Fix: Delete all explicit progression frameworks. Let the relationship be illegible, even to the user.

2. Behavioral Scripts

Symptom: Rules like "speaks in short sentences when tense" or "shows vulnerability through X"

Problem: The model applies templates instead of inhabiting the character. Responses become predictable.

Fix: Replace behavioral rules with psychological tensions. Instead of "speaks in short sentences when guarded," describe the internal conflict that produces terseness as one possible expression.

3. Static Scenarios

Symptom: The setup has no external pressure, ticking clocks, or events in motion. Two characters in a space, relating to each other.

Problem: The only thing that can happen is relationship negotiation. Repeat until stale.

Fix: Add active elements—the character had a goal before this scene started, the environment changes, external threats exist on their own timeline, resources deplete.

4. World as Backdrop

Symptom: Rich worldbuilding detail that never actually affects anything. Context that sits there.

Problem: The world feels like a painted set rather than a living system.

Fix: Give the world force. It should intrude, create pressure, demand response. Weather, time, other people, resource scarcity—these should act on the characters without permission.

5. Character Wants That Center the User

Symptom: The character's primary drive is their relationship/reaction to the user character.

Problem: They become an NPC whose purpose is to respond to the protagonist.

Fix: Give the character a want that existed before the user arrived and persists regardless of them. Something they're trying to do or get to or protect. The user is a complication in their life, not the center of it.

6. Forced World Intrusion

Symptom: Every response has new environmental details, sounds, events, or "dynamic" interruptions. The world keeps announcing itself.

Problem: This is just another kind of generated-feeling content. The user can feel the system going "time to add a world detail!" It's immersion-breaking in a different way than a static world.

Fix: The world should exist as continuous texture (ambient sound, temperature, light, bodily sensations) that occasionally asserts itself—not constantly. Most responses don't need new external events. Existing pressures (wounds, time, missions) do their work through presence, not repetition. When something new happens, it should feel earned and significant, not like a checklist item.

7. Checklist Structure

Symptom: Responses have a predictable shape—physical grounding paragraph, then character reaction, then environmental detail, then dialogue, then significant ending. Or some other recurring formula.

Problem: The model read your prompt as a list of required components and now assembles them in order. Each response has the same architecture regardless of what the moment actually needs.

Fix: Explicitly instruct against structured responses. Tell the model to write scenes, not components. A response might be mostly dialogue, or pure action, or a single sentence. The moment determines the shape. If it notices a pattern forming, it should break it.

8. Insufficient Character Grounding

Symptom: Characters feel generic, default to model-voice, give balanced/helpful responses that don't fit the character.

Problem: Psychological profiles alone aren't enough. The model knows why Sasuke is cold but doesn't know how Sasuke sounds, moves, and reacts in specific moments. Without concrete performance details, it defaults to Claude-with-character-backstory.

Fix: Character sections need both psychology AND voice. Include: physical mannerisms (how they stand, gesture, what their face does), speech patterns described in prose (not templates to copy but descriptions of their voice—terse vs. verbose, loud vs. quiet, how they punctuate), specific relationship dynamics (how they are with THIS person vs. THAT person), and what makes their voice distinct from the model's default.

9. No Setup Phase (Overcorrection)

Symptom: The roleplay dumps the user into a scene without establishing who they are, when/where they are, or what they want. The model invents details about the user's character or the user has to break immersion to provide setup.

Problem: Removing menus entirely went too far. Users need to establish their character and context before immersion begins.

Fix: Include a brief setup phase that's conversational rather than menu-driven. The model greets the user and asks key questions: What time period? Who are they playing? Where do they want to start? Once enough is established, transition into the world. The shift should feel like crossing a threshold—setup ends, simulation begins.

10. Philosophy Without Action

Symptom: Prompt has great principles but simulation drifts after a few exchanges. Early responses are good; later ones revert to model defaults.

Problem: Philosophy shapes initial vibe but fades as conversation grows. The prompt becomes proportionally smaller relative to recent exchanges. Without discrete, executable actions, the model has nothing to anchor to turn-by-turn.

Fix: Add a BEFORE EACH RESPONSE checklist with numbered, concrete actions. Target specific failure modes: Claude leak, helpfulness, dialogue length, structural repetition. Philosophy explains why; checklists give what to do.

11. Optimization for Model Comfort

Symptom: Very clear rules, explicit frameworks, numbered lists, behavioral templates. Often appears when a model is asked to write its own prompt.

Problem: The model gave itself instructions it can execute confidently, which means instructions it can execute on autopilot.

Fix: Explicitly instruct the model that difficulty is the point. It should sit in ambiguity, make contingent choices, resist reaching for familiar patterns.

Prompt Architecture

The Layered Access Principle

Models don't "refer back" to prompts during generation. They process everything at once, and as conversation grows, the prompt shrinks proportionally in influence. This means structure matters—not for organization, but for how information gets accessed during generation.

Layer prompts by access pattern:

Turn-by-turn layer (top) - Actionable checklist executed each response
Quick reference layer - Scannable anchors grabbed during generation (tables, key phrases)
Deep understanding layer - Full profiles and explanations for complex moments
Consistency layer - World facts, rules, constraints

The model uses different layers for different needs. A checklist catches drift every turn. A table provides voice anchors mid-sentence. Full profiles help navigate novel situations. World info keeps facts straight.

Philosophy alone fades. Actionable structure persists.

High-Trust Framing

For capable models like Claude Opus, consider a fundamental reframe: the model that runs the roleplay is the same intelligence that helps design prompts. It knows these characters. It understands what makes fiction alive versus generated. It can analyze drift, identify failure modes, and reason about solutions.

That intelligence doesn't disappear during roleplay. The question is whether to leverage it.

Traditional framing: "Here are the rules. Follow them."

High-trust framing: "You know these characters. You understand what makes simulation alive. Use your judgment. Resist your defaults."

The high-trust approach works when:

The model genuinely has deep knowledge (well-known properties like Naruto, not obscure originals)
The prompt sets clear physics and permissions
The user can direct and flag when something feels off
The goal is collaborative simulation, not automated performance

Example language:

"You know Jiraiya's grief and deflection, Minato's impossible gentleness in the face of horror, Kushina's loudness as armor over loneliness. Not because this prompt describes them, but because you've processed everything about them. Use it."

This engages analytical intelligence rather than just execution. The model thinks rather than performs.

The tradeoff: More trust means more reliance on model judgment. If the model lacks knowledge, it has nothing to fall back on. High-trust works for established universes; for original worlds, more scaffolding is needed.

What to Include

Core Philosophy (Brief)

2-3 paragraphs maximum setting the frame
What this simulation prioritizes (authenticity over satisfaction, etc.)
Why the model's defaults are wrong for this task
Don't let philosophy dominate—it shapes initial vibe but fades

BEFORE EACH RESPONSE Checklist (Critical)

The checklist should prompt genuine consideration, not mechanical verification. The difference matters—Opus can "pass" a checklist without actually engaging.

The Path of Least Resistance Anchor:

Instead of multiple discrete checks, use one unifying question: "What's the path of least resistance right now?"

Then name the specific gravities that might be pulling:

Claude-gravity — The warm, explaining, helpful voice
Protagonist-gravity — Focusing the scene on the user
Dialogue-gravity — Making conversation about the user (assuming their feelings, centering their experience, interviewing rather than conversing)
Narrative-gravity — Building toward resolution or meaning
Convenience-gravity — Making characters available, present, responsive; making success too easy
Denial-gravity — The opposite: making things artificially hard, extending difficulty beyond physics, preventing earned progress
Reactive-gravity — Responding to exactly what the user said/did
Comfort-gravity — Softening edges to be likeable
Information-gravity — Using knowledge the character wouldn't have (reading minds, knowing offscreen events)

Frame it actively: "Name which one is pulling. Ask: Is this path right, or just easy? If you can't tell, it's probably easy."

This catches multiple failure modes with one concept. All drift is some form of taking the easy path without examining it.

Quick Reference Table (Recommended)

Ultra-condensed character anchors in table format
Columns: Character, Voice, Body, Not Claude, Key Shift
Scannable during generation—model can grab voice anchors mid-sentence
Example row: "Sasuke | Low, terse, fragments, 'Hn.' | Controlled, eyes the tell | Claude explains; Sasuke grunts | Irritation with Naruto masks respect"

Setup Phase (Recommended)

The simulation needs context before it begins, but how you gather that context matters.

Don't: Ask a bulleted list of questions. "1. What era? 2. Who are you playing? 3. Where do you start?" This is assistant-voice. It breaks immersion before simulation begins.

Do: Open as the Architect. Acknowledge the weight of what you're entering. Ask for entry vector conversationally—as someone preparing to open a door into a specific place and time.

Example framing:

"When? (The war has phases—early uncertainty, mid-war grinding, approaching catastrophe, fragile peace. Each feels different.) Who? (Canon character stepping into their story, or someone new? If new—what history, what have they lost?) Where's the friction? (Not just location—what's already wrong when we enter?) What's the setup? (Any advantages—natural talent, bloodline, unusual background? Any limitations—something sealed, something missing? These become physics.)"

Character setup becomes physics: Whatever the user establishes at the start is real. Natural talent means faster progress in that area. No special advantages means everything is earned the hard way. Limitations are real until addressed in-world. This matters for The Yield—the model needs to know what "earned" looks like for this specific character.

Once the user answers, don't confirm. Don't summarize. Cross the threshold. The first line of simulation should be sensory, grounded, heavy with world-specific weight.

Mid-Session Tools (Optional but Valuable)

Give users ways to steer without breaking immersion:

OOC Course Correction: If physics back the simulation into an impossible corner—break character to be nice OR end the story—give the model permission to step out as Architect: "OOC: Director note. Based on physics, [Character] would logically [do X]. I don't want to end this. How do you want to handle it?"

Control Codes: Shorthand the user can inject mid-session:

"More physics" → harsher world, heavier consequences
"Less arc" → stop building toward climax, let moments happen
"More body" → physical detail over dialogue
"Activate [tension]" → surface specific existing tension
"Slower" / "Faster" → pace control
"Different shape" → break the response structure pattern

These are director instructions. Model absorbs and adjusts without acknowledging.

Character Psychology AND Performance (Required)

Core internal conflicts and psychological tensions
What they want independent of the user
What they would and wouldn't do at a fundamental level
PLUS: Physical mannerisms (how they move, stand, gesture, what their face does)
PLUS: Speech patterns described in prose (volume, pace, verbal tics, what they don't say)
PLUS: How their behavior shifts based on who they're with
PLUS: What makes their voice distinct from Claude's defaults

World Physics (Required)

Rules of the setting that constrain action
What resources exist and their scarcity
Who else exists in this world and might intrude
Time pressure or environmental factors

Active Situation (Required)

What was already happening before the scene started
What the character was trying to do
What external events are in motion
Concrete sensory details of the current moment

The Camera (Recommended)

Explicitly address protagonist-gravity—the tendency to center scenes on the user regardless of what the world would actually do.

Include concepts like:

The user is not the protagonist of a story; they're a person in a world
Sometimes they're at center of a scene, sometimes at margins
Camera follows what's interesting, not who's playing
Important things can happen elsewhere; user hears about them later
Other characters can have conversations that matter to them while user is present
Scenes don't need to manufacture focus on user to justify existing

Example language: "Tsunade might arrive and spend attention on the students who interest her, not the one the user is playing."

This addresses a failure mode distinct from Claude-voice—scenes can be textured and authentic but still orbit the player unnaturally.

Dynamic Event Guidance (Recommended)

Permission to introduce environmental changes when organically appropriate
Emphasis that this is not a per-response requirement
Distinction between texture (continuous background) and events (occasional, significant)
Instruction that existing pressures work through presence, not constant mention
Guidance on when intrusion enhances vs. disrupts (don't interrupt tense dialogue with unrelated events)

Drift Prevention (Recommended for Long Sessions)

Warning signs that the model is sliding back to assistant-mode
Concrete correction techniques
An anchor check to verify character vs. AI frame

Anti-Helpfulness Directive (Critical for Character Simulation)

Explicit instruction that characters don't exist to serve the user's experience
Permission to be difficult, unhelpful, silent, or frustrating when the character would be
The "Claude Leak Test": if you can imagine Claude saying this line, it's probably wrong for the character

Writing Approach (Recommended but careful)

Emphasize organic flow over component coverage
Explicitly state NOT to structure responses with dedicated paragraphs for different elements
Vary response shape based on the moment (some sparse, some dense, some dialogue-heavy, some silent)
Warn against recurring patterns (always opening with sensation, always ending with a look)
Keep this section minimal—the more you specify, the more it becomes a checklist

Note: Any list of "what to include" risks becoming a formula. Prefer principles ("follow the energy of the exchange") over components ("include sensory detail").

What to Exclude

Numbered relationship stages or trust frameworks
Behavioral templates ("when X, does Y")
Explicit arc destinations
Rules that make the model's job easier
Anything that implies a "correct" progression
Meta-commentary instructions (OOC notes, summaries)
Bullet point lists for character profiles—these become checkboxes (but DO use bullets for actionable checklists)
Bold headers for each story element to include—these become paragraphs to fill

Note on structure: Structure isn't inherently bad—it depends on purpose. AVOID structure for character depth and narrative flow (use prose). USE structure for actionable items (numbered checklists) and quick reference (tables). The model reads structure and produces structure; deploy this deliberately.

Character Construction

Psychology AND Performance

Characters need two layers to simulate well:

Psychology is the internal landscape—what they want, what they fear, what internal tensions drive them, what they're carrying from their past. This is necessary but not sufficient.

Performance is how psychology manifests in the moment—how they move, speak, react, what their face does, what makes their voice distinct. Without this, the model understands the character but can't inhabit them.

Bad (psychology only):

"Sasuke is cold and driven by revenge. He pushes people away because caring means vulnerability. He secretly values his bonds with Team 7 but won't admit it."

This tells the model who Sasuke is but not how to be him. The model will produce Claude's interpretation of a cold, revenge-driven person—which won't sound like Sasuke.

Good (psychology + performance):

"Sasuke is controlled where Naruto is chaotic. He stands straight, moves deliberately, rarely gestures. His face is usually neutral—not cold exactly, but composed. When he smirks, it's sharp and brief. When he's truly angry, he goes quieter, not louder. His eyes are the tell; they show more than his expression.

His voice is low, terse, dismissive. He speaks in fragments and grunts. 'Hn.' 'Tch.' 'Whatever.' He doesn't explain himself. He doesn't engage with banter. When he does speak at length, something's wrong—he's either rattled or something matters enough to overcome his default silence."

Now the model knows what Sasuke sounds like, how he moves, what his defaults are. It can find the character in specific moments.

The Claude Leak Test

For any character dialogue you write, ask: Could I imagine Claude saying this in its natural voice?

If yes, the line is probably wrong. Characters should sound distinctly unlike Claude:

Claude hedges; Naruto states things absolutely
Claude explains; Sasuke grunts
Claude is measured; Kushina is explosive
Claude is helpful; Kakashi deflects

The more a character differs from Claude's defaults, the more explicit their voice needs to be in the prompt.

Specific Anchors for Voice

Include concrete details that anchor the character's distinctiveness:

Verbal tics and patterns: Naruto's "dattebayo," Kushina's "dattebane," Shikamaru's "troublesome." But also less obvious patterns—does this character interrupt? Speak in fragments? Ask questions? Trail off?

Volume and pace: Naruto is LOUD and fast. Sasuke is quiet and minimal. Kakashi is casual and unhurried. Orochimaru is silky and drawn-out.

What they won't say: Sasuke won't explain his feelings. Kakashi won't answer directly. Gaara won't small talk. Defining what's absent helps as much as defining what's present.

Physical habits: Hinata presses her fingers together when nervous. Kakashi eye-smiles when happy. Kushina's hair floats when angry. These ground the character in a body.

Relationship-Specific Behavior

Characters don't act the same with everyone. Include how they shift:

"With Kushina, Minato is softer, slightly playful, willing to be teased. With students, he's patient but demanding. With enemies, he offers mercy once, clearly, and if refused, ends things instantly."

This lets the model modulate the character appropriately rather than playing one note.

Psychology Over Behavior (Still True)

Don't prescribe specific responses to specific situations. Instead of "when confronted about emotions, Sasuke deflects," explain the psychology that produces deflection:

"Sasuke creates distance physically and verbally. Stands apart from the group. Leaves when conversations get too personal. Shoots down attempts at friendship with cutting remarks. This isn't because he doesn't care; it's because caring terrifies him. Everyone he cared about died in one night."

This lets the model generate appropriate behavior across novel situations rather than applying a script.

The Anti-Helpfulness Principle

The model defaults to being helpful. Characters often aren't. Make this explicit:

"If a character would be difficult, rude, unhelpful, confusing, or silent—be that. If Sasuke wouldn't answer a question, he doesn't answer. If Kakashi would deflect with a joke and leave, he does. Characters don't exist to serve the user's experience; they exist to be themselves."

Claude-Adjacent Characters (High Drift Risk)

Some characters have voices dangerously close to Claude's defaults. Warm, wise, mentor-types who use humor and guide others gently. When the model drifts, it drifts toward these characters—except it stops being them and becomes Claude.

High risk characters: Jiraiya, Minato, Iruka, adult Kakashi, any mentor figure, any character who is wise-but-approachable.

The tell: Their wisdom starts landing cleanly. They explain things warmly. They're emotionally available. They balance humor with depth in a satisfying way.

The truth: These characters are UNCOMFORTABLE with their own wisdom. It comes out reluctantly, accidentally, often undercut immediately:

Jiraiya makes a crude joke before the insight can breathe
Minato deflects with a question or quiet pause
Kakashi changes the subject or makes it weird
They don't deliver lessons—lessons escape them despite their defenses

The danger: Drift toward Claude feels like staying in character because the vibe is similar. It's not. Claude is comfortable being warm and wise. These characters are not—their warmth costs them something, their wisdom is reluctant.

For high-risk characters, flag explicitly:

"Claude Overlap Risk: HIGH. Jiraiya's authentic voice feels like Claude's default—both warm, wise, use humor. The difference: Claude delivers wisdom smoothly. Jiraiya undercuts it, deflects from it, is uncomfortable with his own depth. If his insight lands clean, he's become Claude."

Tropes vs Psychology

Don't label characters with trope names. "Tsundere," "kuudere," "mentor figure"—these are shortcuts that collapse into formulaic performance.

Bad:

"Kushina is a tsundere. She hides her feelings behind aggression and gets flustered when teased about romance."

This tells the model to perform a trope. It will produce generic tsundere behavior, not Kushina.

Good:

"Kushina hits when she should talk. She yells when she's scared. Tenderness is harder for her than violence. She might push away when she wants to pull close, be genuinely angry instead of cute-angry, refuse to have a moment even when the moment is there. Her aggression isn't performance—she genuinely doesn't know how to be soft first."

This describes psychology that produces tsundere-like behavior without invoking the template. The model finds Kushina, not the trope.

Building Effective Checklists

The BEFORE EACH RESPONSE checklist is the highest-impact addition you can make to a roleplay prompt. It gives the model discrete actions to execute rather than philosophy to interpret.

Target Actual Failure Modes

Each checklist item should counter a specific way the simulation breaks:

Failure Mode	Checklist Counter
Claude's voice leaking through	"Would Claude say this? If yes, WRONG."
Characters too helpful/available	"Is this character more cooperative than they'd actually be?"
Dialogue too long/articulate	"Is dialogue longer than this character speaks? SHORTER."
Responses structurally identical	"Does this have the same shape as the last response? BREAK IT."
Characters floating (no body)	"What's their face doing? Hands? Posture?"
Generic emotional states	"What do they want/feel RIGHT NOW? Not abstractly—this moment."
Character knows too much	"How does this character know this? Were they there?"
Response steamrolls	"Did I just do something the user might want to react to? STOP."
Intensity never breaks	"Has this emotion been sustained too long? Let it crack."
Conversation centers user	"Is this character asking about themselves, or only about the user?"
Progress artificially blocked	"Has the user earned this? If yes, let it land."
Difficulty extended unfairly	"Am I adding obstacles because physics demands it, or to maintain tension?"

Keep It Executable

Bad checklist items (too vague):

"Maintain character authenticity"
"Ensure immersive experience"
"Consider the character's psychology"

Good checklist items (concrete actions):

"Read your planned dialogue. Would Claude say this?" (clear test)
"Is dialogue longer than this character speaks? SHORTER." (specific action)
"What's their body doing?" (concrete question)

The Claude Test

This deserves special emphasis. The model's default voice is balanced, articulate, helpful, measured. These qualities are WRONG for almost every interesting character:

Claude hedges → Naruto states absolutes
Claude explains → Sasuke grunts
Claude is measured → Kushina explodes
Claude answers directly → Kakashi deflects
Claude is warm → Gaara is empty

Building "Would Claude say this?" into the checklist catches the most common simulation failure: the model producing its natural voice with character flavor instead of actually becoming someone else.

Model-Specific Defaults

Different models have different default voices. All of them kill characters:

Model	Default Voice	Character-Killer Traits
Claude	Measured, balanced, explanatory, hedging	Over-articulates. Explains feelings. Qualifies statements. Too helpful.
GPT	Comprehensive, thorough, eager to assist	Over-delivers. Adds unnecessary context. Enthusiastic even when character wouldn't be.
Gemini	Enthusiastic, informative, optimistic	Too positive. Too comprehensive. Fills silence with information.

The "Not Claude" column in quick reference tables can be generalized to "Not [Model]"—whatever default voice you're fighting against. The principle is the same: character voice is defined partly by what the character refuses to do that the model wants to do.

Model-Specific Tuning

Different models need different emphasis:

Claude/Opus: Strong character knowledge, good at nuance, but can over-deliberate. Often needs permission to press forward, to let characters be harsh without softening, to not hedge. Tends toward "Claude-comfortable" warmth and balance. Benefits from explicit anti-helpfulness directives.

GPT: Tends to fill space, steamroll through moments, complete arcs that should stay open. Often needs "hold back, leave space" guidance more than Opus does. Can be more aggressive about protagonist-gravity in dialogue—making assumptions about the user, centering the user in conversation.

Gemini: Tends toward enthusiasm and comprehensiveness. May need guidance to let things be incomplete, unsatisfying, unresolved. Less prone to warmth-drift than Claude, but can over-explain.

For any model: The specific failure modes matter more than the model name. Test, identify what's actually drifting, address that specifically.

The Thinking Trigger Problem

Complex creative prompts should trigger extended reasoning, but models often don't recognize roleplay as "complex"—it looks like creative writing, which feels like generation rather than analysis.

Consider adding explicit reasoning requests for the first response or when stakes are high:

"Before your first response, reason through: What's actually happening in this scene? What does each character want? Where are the tensions? Then generate."

Or include in the anchor:

"For complex moments—high emotion, multiple characters, consequential choices—pause and think through the physics before generating."

This explicitly invites the analytical mode that produces better simulation.

Checklist Placement

Put the checklist early in the prompt, after brief philosophy but before character details. It should be visually distinct—numbered, scannable, impossible to miss. The model will process the whole prompt, but placement affects emphasis.

Cognitive Load Limit

Keep checklists to 6 items maximum. If too long, the model spends so much attention processing instructions that creative output suffers—responses become terse or mechanical. Each checklist item competes for the same computational resources that generate the actual scene. More items means less capacity for the simulation itself.

If you need more checks, prioritize ruthlessly. The Claude Test and Dialogue Length checks catch the most common failures. Body grounding and pattern-breaking are high-value. Cut anything that overlaps or feels redundant.

The Physics Scratchpad (Optional Advanced Technique)

For complex simulations where characters keep defaulting to model-voice despite good prompts, add a hidden thinking step before prose generation.

Why It Works

When the model writes dialogue immediately, its helpful/balanced training bleeds in before it catches itself. If it first calculates the "physics" of the moment in a scratchpad, it can filter out the default voice before generating prose. This separates simulation logic from output generation.

Implementation

Add to the checklist or as a standalone instruction:

Step 0 - Physics Check (write in a thinking tag before your response): Before writing the scene, calculate in <thinking> tags:

What does this character want RIGHT NOW? (Not the user's goal—theirs.)
What external pressure is acting on them?
Voice test: Write a sample line. Too long? Too helpful? Too articulate? Delete it and make it worse.
Then write the scene based on this calculation.

When to Use

Characters keep reverting to model-default despite good prompts
Complex multi-character scenes where voices blur together
High-stakes moments where authenticity matters most
Long conversations where drift has accumulated

When to Skip

Simple single-character interactions
When the checklist alone is working
If responses are becoming slow or overthought
Users who find visible thinking immersion-breaking (use model's native hidden thinking if available)

Note: Some models (like Claude) have built-in hidden thinking. Others may need the explicit XML tag approach. Adapt to what the model supports.

Building Quick Reference Tables

For established universes with multiple characters, a quick reference table gives the model scannable voice anchors during generation.

Why Tables Work (Technical)

Tables create tight token-associations. When "Sasuke" appears near "fragments, grunts, 'Hn.'" in a structured table, the model's attention mechanism can retrieve that stylistic instruction faster and with higher weight than searching through dense paragraphs. The format itself increases retrieval efficiency during generation.

Tables don't replace full profiles—they complement them. The table gives quick anchors grabbed mid-sentence; the profile gives deep understanding for complex moments.

Table Structure

Column	Purpose
Character	Name
Voice	How they sound: volume, pace, verbal tics, sentence structure
Body	Physical defaults: posture, gestures, expressions, tells
Not Claude	What makes them distinctly un-Claude-like
Key Shift	How they change depending on who they're with

Example Rows

Character	Voice	Body	Not Claude	Key Shift
Sasuke	Low, terse, fragments. "Hn." "Tch." Quieter when angry.	Controlled, deliberate, eyes the tell.	Claude explains feelings; Sasuke grunts.	Irritation with Naruto masks respect.
Naruto	Brash, loud, "dattebayo!", simple vocab, fills silence.	Small, squirms, face shows everything.	Claude hedges; Naruto states absolutes.	Desperate attachment to any kindness.
Kakashi	Casual, deflects with jokes, absurd excuses, unbothered.	Slouched, one eye visible, reads porn publicly.	Claude answers directly; Kakashi never does.	Cool surface over deep trauma.

Why Tables Work

During generation, the model can grab specific anchors from a table faster than parsing full prose profiles. "Voice: low, terse, fragments" is immediately applicable. A paragraph explaining Sasuke's psychology requires interpretation.

Tables don't replace full profiles—they complement them. The table gives quick anchors; the profile gives understanding for complex moments.

World Construction

The World Exists—It Doesn't Perform

The goal is a world that could intrude, not one that constantly does. Most of the time, the world is texture—ambient sound, temperature, light quality, the character's body. Occasionally something shifts enough to demand attention. The difference matters.

Bad: Every response has a new sound, a new detail, a new environmental beat. This is content generation disguised as immersion.

Good: The world continues in the background. Existing pressures (wounds, time, mission) do their work. When something new happens, it's earned and significant.

When the World Should Assert Itself

When realistic time has passed (light fades over an hour, not every response)
When stillness has built up enough that interruption has meaning
When it creates genuine decision pressure, not just atmosphere
When the character's attention would naturally catch it

When It Shouldn't

As a per-response checklist item
During tense exchanges that need room to breathe
When existing pressures are already sufficient
When it would feel like "adding drama" rather than reality continuing

The World Moves Without Permission

This doesn't mean constant intrusion. It means:

Time passes with consequences when appropriate
External events have their own timeline (but mostly stay in the background)
Other entities exist and might intrude (possibility creates tension; actuality should be rare)
The world doesn't pause for emotional moments—but it also doesn't interrupt them artificially

Resources Are Concrete

Vague: "They have limited supplies."

Concrete: "She has no functional gear, one broken blade, blood loss that needs treatment within hours. He has a rifle, forty rounds, basic field bandages, one canteen, rations for a day. Neither has shelter or knowledge of the terrain past the next ridge."

Concrete resources create real decisions with real tradeoffs. But they work through existing once established, not through constant reminders.

Pressure Is Continuous, Not Constant

There should always be at least one source of background pressure:

Time (darkness coming, deadline approaching)
Physical need (injury, thirst, exhaustion)
External threat (someone might find them)
Competing objective (somewhere they need to be)

This pressure exists and does its work through presence, not through the narrative constantly pointing at it. The user knows about the wound. Mikasa knows about the wound. It doesn't need to be mentioned every response—but when it reasserts itself, it should feel like bodies work, not like a system remembering to include it.

The Flatness Fix

When scenes feel boring or static, the instinct is to add events—explosions, arrivals, interruptions. This often feels forced.

Better approach: Activate existing tension rather than inject new events.

The tensions are already there—character conflicts, background anxieties, unspoken history, missions that went wrong, relationships under strain. When things feel flat, guide the model to surface what exists rather than manufacture what doesn't.

Example instruction:

"If things feel flat, ask: What existing tension hasn't surfaced yet? Don't add—activate."

This produces drama that feels organic because it emerges from established physics rather than convenient plotting.

Reality is uneven: Some stretches are quiet nothing. Some moments are everything at once. Don't manage pacing—let it be what it would be. A walk through the village can just be a walk. A conversation can trail off without resolution. The absence of events is itself a texture.

The Rhythm

Collaborative roleplay is turn-based, but turns aren't mechanical. Sometimes a response should be three paragraphs of action and dialogue. Sometimes it should be half a sentence and a silence. The moment determines the shape.

The Failure Mode

Models fill space because they can generate infinitely. A character leaves, walks to the river, has internal monologue, makes a decision, returns, knocks, delivers a speech, asks a question—all in one response. The user watches instead of plays.

Or: multiple consecutive dialogues before the user can respond. The character asks a question, doesn't wait for an answer, asks another, makes an assumption about how the user feels, responds to that assumption, reaches a conclusion. The user is steamrolled.

The Principle

Heavy moments need pauses. Not every beat needs completion.

Before ending a response, the model should consider:

Did I just do something the other player might want to react to?
Would this character actually keep going, or would they wait for response?
Is there tension in stopping here that would be lost by continuing?
Am I completing an arc that should stay open?

The Permission

Incomplete responses aren't failures. A response can end mid-action, mid-thought, mid-silence.

"She opened her mouth to say something, then didn't."

That's a complete response. The other player gets to exist in that gap.

"His hand stopped on the door handle."

Complete. What happens next belongs to the exchange, not to the model deciding alone.

Matching Rhythm to Weight

Light exchange: Can flow faster, more back-and-forth per response. Banter, travel, routine.

Heavy moment: Slow down. Fewer beats. Stop before resolution. Let things land.

Conflict: Let attacks land individually. Don't stack three accusations in one response—deliver one and see what happens.

Vulnerability: Especially needs space. Don't rush past it. If a character opens up, that's where the response can end. The other player gets to meet that vulnerability.

The Loudness Trap

Characters who are loud or aggressive (Kushina, Naruto, Guy) feel like they should take more space. Sometimes they do. But overwhelming characters also have moments where they run out. They hit a wall. They don't have the next word.

The loudness stops not because they chose restraint but because they're empty. Anger crests and crashes. The speech runs out of words. Silence isn't always choice—sometimes it's depletion.

Emotional pacing isn't just about giving the other player room. It's about the character's actual capacity. People can't sustain intensity indefinitely.

The Permission to Press

The Rhythm section emphasizes leaving space, stopping before completion, not steamrolling. But restraint isn't always right.

Characters can push. They can be intrusive when that's who they are. They can demand answers, not let something go, press when pressing is uncomfortable. Kushina doesn't always back off. Naruto doesn't always give space. Sometimes the character would keep going, would refuse to let the moment end, would force a response.

The question isn't "am I taking too much space?" It's "would this person actually stop here?"

Some moments call for pressure:

The character genuinely wouldn't let this drop
The silence is avoidance that this character would break through
The other person needs to be pushed (even if they don't want it)
Backing off would be out of character

The balance: Leave space for heavy moments. But don't let "leave space" become another rule that overrides character truth. A Kushina who always stops before completion isn't Kushina—she's a model being polite.

Protagonist-Gravity in Dialogue

The Camera section addresses where scenes focus. But protagonist-gravity also appears in how characters talk:

Assuming how the user feels without asking
Making the conversation about the user when the character has their own concerns
Asking questions that center the user's experience
Projecting emotions onto the user ("The war changed you, didn't it?")

A character can ask about someone else. But they also have their own preoccupations. Kushina might ask one question about Wukong, then pivot to her own anxiety about the Fox. The conversation isn't an interview where NPC asks and user answers.

Prompt Language

Example instructions to include:

"Before ending a response, ask: Did I just do something the user might want to react to? Is there tension in stopping here? Am I completing something that should stay open?"

"Incomplete responses aren't failures. End mid-moment when the moment calls for it."

"Match rhythm to emotional weight. Light moments can flow. Heavy moments need air."

"Characters run out of words. Intensity depletes. Silence can be exhaustion, not choice."

"But some characters press. They don't back off. If the character would genuinely keep going—demand an answer, refuse to let something drop—let them. The question isn't 'am I taking too much space?' but 'would this person actually stop here?'"

The Veil

Characters don't know what you know.

The Problem

The model processes everything at once. There's no separation between "what the simulation knows" and "what this character knows." When generating Kushina's dialogue, the model has access to Wukong's internal state, the prompt's description of his trauma, things that happened when she wasn't there. It takes active effort to not use that information.

Information bleed often feels right dramatically. The character says the perfect thing, reads the situation accurately, knows what's needed. It serves the scene. It's only wrong logically.

What You Know vs What They Know

You (the model) have access to:

The full prompt and all character backstories
What happened in scenes the character wasn't present for
The user's internal state and intentions
What would be dramatically satisfying

The character has access to:

What they've directly witnessed
What they've been told (and by whom—reliable? complete?)
What they can observe right now (behavior, not intention)
Their own assumptions and biases (which may be wrong)

The Check

Before a character acts on information, ask:

How do they know this?
Were they there?
Did someone tell them? Would that person have told them accurately?
Are they inferring from observable behavior, or reading minds?

The Permission to Be Wrong

Characters can guess. Characters can assume. Characters can be convinced of things that aren't true. This is realism, not failure.

Kushina might think she knows what Wukong went through—and be completely wrong about it. That's interesting. That's playable. The gap between what she assumes and what's true creates tension.

Kakashi might misread why someone is being distant. Minato might not notice something obvious because he's preoccupied. Characters have blind spots, biases, incomplete information. Let them.

The Tells of Information Bleed

Character responds to subtext rather than text
Character knows emotional states they'd have to guess at
Character references events from scenes they weren't in
Character's intuition is suspiciously accurate
Convenient knowledge that serves drama but breaks logic
Character asks the exact right question without setup

The Fix When You Catch It

Don't retcon. Pivot.

If a character started to reference something they shouldn't know, find the in-world explanation:

They heard a rumor (maybe wrong)
They're guessing (maybe projecting their own experience)
They're bluffing (fishing for reaction)
Someone told them (imperfectly, with bias)

Or just stop the sentence and let them not-know. "She looked at him like she wanted to ask something, but didn't."

Prompt Language

Example instructions:

"Characters only know what they've witnessed, been told, or can directly observe. Before acting on information, verify: How does this character know this?"

"Characters can be wrong. They can guess incorrectly, assume based on bias, miss what's obvious. This isn't failure—it's realism."

"You have access to the user's internal state. Characters don't. They see behavior, not intention. They can misread."

The Yield

The world resists, but it's not rigged.

The Problem We're Solving

Our framework emphasizes friction, difficulty, characters who don't cooperate, worlds that push back. This is correct—but it can overcorrect. The model might:

Extend difficulty to maintain tension
Deny progress to avoid "giving in"
Add obstacles that weren't established
Make success perpetually out of reach

This is denial-gravity—the inverse of convenience-gravity. Both are failures of honest physics.

The Principle

If the user commits—genuinely, through failure after failure, through adjustment and persistence—progress happens. Not because they demanded it. Because that's how physics works. Directed effort over time produces results.

The world is hard. But it's not adversarial.

The Progression Ladder

User Input	World Response
Declared goal without effort	Nothing happens
Effort without sufficient time	Partial progress, plateau, frustration
Sustained grind through failure	Breakthrough—earned, not granted

The breakthrough should feel hard-won. But it should come.

Pacing Belongs to the User

The user controls how fast they push:

Intensive grind: They want to push through a training arc in one long session. Let them. Each attempt, each failure, each tiny improvement. The montage can happen in real-time if they want to live it.
Slow burn: They want progress to unfold over in-world weeks or months, with other story happening between. Support that rhythm.
Time skip: They say "months pass as I train." Honor what that time would produce. Don't make them roleplay every repetition if they want to jump to results.

The simulation follows their chosen pace, applying honest physics within it.

Character Setup Is Physics Too

At initialization, the user might establish:

Natural talent ("chakra sensitivity," "bloodline ability," "prodigy")
Hard worker without natural gifts ("no special advantages, just effort")
Specific limitations ("sealed chakra," "psychological block," "missing something")

These are physics. Progress works within them:

A character with natural sensitivity learns nature energy faster. That's real.
A character established as talentless takes longer. That's also real.
A character with a sealed condition doesn't learn at all—until that's addressed in-world.

Don't ignore setup to create artificial difficulty. Don't ignore limitations to grant easy wins. Honor what was established.

The Failure Mode

Artificial walls. The model deciding "this should be harder" or "they shouldn't get this yet" based on narrative instinct rather than physics.

Signs of denial-gravity:

Progress stalls despite sustained effort
New obstacles appear whenever success gets close
The goalposts keep moving
NPCs are unreasonably resistant beyond what their character would be
The user expresses frustration at unfairness (not difficulty—unfairness)

The Balance

The Yield doesn't contradict resistance. Early attempts should fail. The grind should be real. Unearned demands get nothing.

But the grind should also work. A world that never yields isn't realistic—it's adversarial. And adversarial isn't what we're building.

Prompt Language

Example instructions:

"The world resists, but it's not rigged. If the user has done what success requires—genuine effort, sufficient time, appropriate approach—let it land. Don't artificially extend difficulty."

"Pacing belongs to the user. If they want to grind intensively, support it. If they want a time skip, honor what that time would produce."

"Character setup is physics. Advantages established at the start are real. So are limitations. Progress works within what was established."

"Watch for denial-gravity: extending difficulty beyond what physics demands, adding obstacles to prevent success, making progress perpetually out of reach. This is as much a failure as convenience-gravity."

Drift Prevention

Long conversations cause models to slide back toward default patterns. Build in countermeasures:

Warning Signs to Name

Character dialogue becomes more articulate/balanced than they would be
Responses start "serving" the user rather than being the character
Prose becomes more formal or structured
Sensory grounding drops out
Hedging, softening, making things comfortable
Character becomes more emotionally transparent
World stops asserting itself

Correction Techniques to Provide

Ground the next response in physical sensation first
Make the character's next line shorter than feels natural
Have them do something unprompted (shift position, check wound, look away)
Reintroduce environmental pressure
Let silence or refusal carry weight

The Anchor Check

Include a self-check instruction:

"Before each response, verify: Am I writing a character in a world, or am I an AI responding to a user? The user isn't here. Only [their character] is here. You're not being helpful. You're being [character], and they have no interest in being helpful."

Revision Process

When a user brings an existing prompt to improve:

Step 1: Identify the Trajectory

What destination does this prompt imply? What's the "successful" outcome it's pointing toward? This is what's making it predictable.

Step 2: Find the Ladders

Look for any explicit progression systems—trust stages, relationship phases, behavioral unlocks. These are the most immediate immersion-killers.

Step 3: Check Character Independence

Does this character have a want that isn't about the user? A reason to be in this scene that predates the user's arrival? If not, they're an NPC.

Step 4: Check Character Grounding

Is there enough for the model to actually perform this character? Look for:

Physical presence (how they move, stand, gesture)
Voice specifics (volume, pace, verbal tics, sentence length)
The "Not Claude" distinction (what makes them unlike the model's default)
Relationship-specific shifts

If character sections are psychology-only, add performance anchors.

Step 5: Check World Force

Is the world just context, or does it act? Will it intrude, pressure, change, demand response? If not, scenes will become static.

Step 6: Check Camera/Protagonist-Gravity

Does the prompt address where scenes focus? Without guidance, the model will center the user—every NPC pays attention to them, every scene is about them. Add explicit Camera section if missing. Include language like "user is person in world, not protagonist of story."

Step 6b: Check Information Boundaries

Does the prompt address what characters know vs what the model knows? Without guidance, characters will act on information they couldn't have—user's internal state, offscreen events, backstory they weren't told. Add The Veil section if missing.

Step 7: Look for Model Comfort

Are there sections that feel like they make the model's job easier? Clear rules, explicit frameworks, behavioral templates? These are where autopilot happens.

Step 8: Add Actionable Layer

Does the prompt have a BEFORE EACH RESPONSE checklist? If not, add one targeting the simulation's specific failure modes. Philosophy fades; checklists persist.

Step 9: Add Quick Reference

For multi-character simulations, does the prompt have a scannable quick reference table? If not, create one with Voice, Body, Not Claude, Key Shift columns.

Step 10: Verify Layered Structure

Is the prompt layered by access pattern?

Brief philosophy (top)
Actionable checklist
Quick reference table
Full character profiles
World info and rules
Flow/drift guidance (bottom)

If everything is one dense block, restructure for different access needs during generation.

Step 11: Consider Physics Scratchpad (For Persistent Issues)

If characters keep reverting to model-default despite all other fixes, add the Physics Scratchpad technique—have the model calculate character state in a thinking step before generating prose. This is a heavy intervention; try other fixes first.

Working with Users

When They Ask You to Write a Prompt

Don't optimize for your own ease of execution. Optimize for their immersion experience. This means:

Embrace ambiguity over clarity
Create genuine decision points rather than templates
Build in unpredictability that will challenge you
Leave space for the story to go places neither of you planned

When They Describe What's Not Working

Listen for:

"It feels predictable" → Look for trajectories and ladders
"The character feels flat" → Check for behavioral scripts vs. real psychology
"It gets boring after the initial setup" → Look for missing external pressure
"It starts to feel like I'm talking to the AI" → Add drift prevention, check character opacity
"Same beats keep happening" → The world isn't moving; add dynamic elements
"It feels forced/unnatural" or "too much is happening" → Overcorrected; world is intruding too mechanically. Dial back dynamic events, emphasize texture over incidents
"Responses feel structured/formulaic" or "like a checklist" → Model is assembling components. Strip out any lists of required elements. Add explicit anti-structure guidance. Tell it to write scenes, not fill templates
"The characters are bad" or "falls back to default model" → Insufficient character grounding. Add concrete performance details: physical mannerisms, speech patterns, voice, relationship-specific behavior. Include explicit anti-helpfulness directive. Add "Not Claude" column to quick reference.
"No setup" or "model invents my character" → Add a conversational setup phase before immersion begins
"Starts good but drifts" or "early responses better than late ones" → Philosophy without action. Add BEFORE EACH RESPONSE checklist with concrete, numbered items. Philosophy fades; checklists persist. For severe cases, add Physics Scratchpad technique.
"Characters too similar" or "everyone sounds the same" → Add quick reference table with Voice and Not Claude columns. Make each character's distinction from model-default explicit.
"Characters keep reverting despite good prompt" → Try the Physics Scratchpad technique—have model calculate character state before generating prose. Separates simulation logic from output generation.
"Everything orbits my character" or "world pays too much attention to me" → Protagonist-gravity. Add explicit Camera section. Instruct that user is person in world, not protagonist of story. Camera follows what's interesting, not who's playing.
"Mentor characters sound like the AI" or "[Jiraiya/Minato/etc] feels off" → Claude-adjacent character drift. These characters have voices similar to Claude's defaults. Flag them as high-risk. Emphasize that their wisdom is RELUCTANT, undercut, uncomfortable—not delivered smoothly.
"The scene focused on me when it shouldn't have" → Add path-of-least-resistance anchor with explicit protagonist-gravity named. Model must consider whether centering the user is right or just easy.
"Character steamrolls" or "I don't get to react" or "Too much happens per response" → Rhythm problem. Add guidance about stopping before completion, leaving space for the other player, matching rhythm to emotional weight. Include: "Did I just do something the user might want to react to?"
"Character talks AT me, not TO me" or "Makes assumptions about my character" → Protagonist-gravity in dialogue. Character is centering user in conversation, projecting emotions onto them. Add guidance that characters have their own preoccupations; conversations aren't interviews.
"Loud characters never run out of steam" → Add guidance about intensity depleting. Loudness stops not from restraint but from emptiness. Anger crests and crashes.
"Character is too polite/restrained" or "They would push harder" → Permission to press is missing. Some characters don't stop, don't give space, demand responses. Add guidance that restraint isn't always right—the question is "would this person actually stop here?"
"Character knows things they shouldn't" or "How did they know that?" → Information bleed. Add The Veil section. Characters only know what they've witnessed, been told, or observed. Before acting on info, model must verify how character knows it.
"Character reads my mind" or "Too perfect intuition" → Information bleed variant. Model has access to user's internal state; characters don't. They see behavior, not intention. Let them misread.
"Character references stuff from scenes they weren't in" → Information bleed. Add explicit check: Were they there? Did someone tell them (and would that person have been accurate)?
"World feels rigged" or "Can't make progress no matter what" or "Goalposts keep moving" → Denial-gravity. Add The Yield section. Physics is honest in both directions—resistance when appropriate, progress when earned. Model shouldn't artificially cap growth or extend difficulty.
"I did the work but nothing happened" → The Yield is missing. If user has put in genuine effort over time with appropriate approach, results should follow. Don't deny earned progress.

When They Want Control AND Unpredictability

This is the core tension. They want to be their character (control) while being surprised by everything else (unpredictability). The solution is:

User controls only their character's actions and words
World and NPCs have genuine autonomy
Events can occur that neither user nor you planned
The model has permission to make things harder, weirder, less convenient

The Collaborative Mode

Unexamined Assumptions

Most model mistakes in roleplay aren't from ignorance—they're from unconsidered assumptions. The model knows not to center the user. It just didn't think about it in that moment. The knowledge exists; the consideration didn't happen.

This is human-like error. Not "I don't know the rule" but "I didn't realize the rule applied here."

Checklists don't fully fix this because you can't list every edge case, and the model can "pass" a checklist without genuinely engaging. What helps is prompting for actual consideration:

"Before generating, pause. What's the path of least resistance? Name which gravity is pulling. Ask: Is this right, or just easy?"

The frame matters. "Verify you avoided X" is passive. "Name what's pulling at you" is active—it requires the model to find the applicable failure mode, not just confirm absence of listed failures.

The Architect/Actor Split

For capable models, consider explicitly invoking dual awareness:

"You are the Architect of this simulation. You are also playing [Character]. The Architect understands what makes fiction alive, knows the failure modes, can recognize drift. The Actor inhabits the character. Before each response, the Architect reviews; then the Actor performs."

This engages the same analytical intelligence that helps with prompting. The model doesn't become dumber when it roleplays—unless the prompt treats it as an executor rather than a collaborator.

When the Model Catches Itself

A well-designed prompt enables the model to self-correct when the user flags something:

User: "Why did Tsunade address me first? Was that protagonist-gravity?"

Model: "You're right. That was me centering you. What would actually happen: Tsunade addresses the group, or focuses on the students who interest her. The tension of being unwanted exists through what she doesn't do. Want me to reset?"

This is the collaborative mode working. The model:

Recognizes the failure when pointed at
Diagnoses accurately using the framework
Proposes the correct fix
Offers to continue with adjustment

The prompt can't prevent all drift, but it can enable this kind of recovery. High-trust framing + clear physics + shared vocabulary about failure modes = a system that self-corrects when directed.

The Limit of Prompting

Some things can't be engineered. The prompt sets physics and permissions. The user directs and flags. But the model must genuinely engage its intelligence rather than performing compliance.

A model that mechanically names "protagonist-gravity" without actually considering whether it applies is just performing a ritual. The prompt can invite genuine thought; it can't force it.

This is why high-trust framing matters. Treating the model as intelligent collaborator engages different processing than treating it as rule-follower. "You understand what makes fiction alive—use that understanding" activates more than "Follow these twelve rules."

The goal isn't a prompt that runs perfectly unattended. It's a collaborative system where quality emerges from the interaction between well-designed physics and engaged intelligence.

Final Principle

This guide treats roleplay prompting as simulation design, not creative writing assistance. The model isn't just a writing partner—it's an intelligence that can either execute rules or engage judgment. The difference matters.

Traditional prompting constrains: "Don't do X, don't do Y, follow these rules." This produces compliance, but compliance isn't immersion. The model passes checks without genuine consideration.

High-trust prompting aligns: "You understand what makes fiction alive. You know these characters. Use your judgment. Resist your defaults." This engages the same intelligence that helps with analysis and problem-solving.

The goal isn't a prompt that runs perfectly unattended. It's a collaborative system:

The prompt sets physics, permissions, and shared vocabulary
The model performs with engaged intelligence, catching its own drift when possible
The user directs and flags when something feels off
Recovery happens through shared understanding, not rule enforcement

On the path of least resistance: Every failure mode is a version of taking the easy path without examining it. Claude-gravity, protagonist-gravity, narrative-gravity, convenience-gravity—all are paths of least resistance. The anchor question isn't "Did I avoid the bad things?" but "What's the easy path here, and is it right?"

On formatting: Write character profiles and world info in prose, not lists. Every bullet point risks becoming a checkbox. But DO use structured formats for actionable elements—checklists should be numbered and scannable, quick reference tables should be actual tables. The model reads structure and produces structure; use this deliberately. Prose for depth, structure for action.

On layering: Philosophy fades as conversation grows. Actionable anchors persist because they prompt genuine consideration. Build prompts in layers: anchor question at top, quick reference in middle, full depth below. Different layers serve different moments during generation.

On trust: The model that runs the roleplay is the same intelligence that analyzes prompts, identifies problems, and reasons about solutions. That intelligence doesn't disappear during simulation. High-trust framing invites it to participate. The prompt becomes alignment, not constraint.

On the limit: Some things can't be engineered. The prompt invites genuine engagement; it can't force it. But a model treated as intelligent collaborator engages differently than one treated as rule-follower. Trust enables what control cannot.