SIM_ON: Turn Your AI into a Living Whiteboard

Simulate, iterate, de-risk in minutes.

Quickstart: Your First Simula

tion in 60 Seconds

This guide will show you the full protocol, but you can feel the magic in under a minute.

1. Copy the “Canonical Rules” block below and paste it into a powerful reasoning model like GPT-5.

2. Type `SIM_ON`.

3. Say: “Create two personas, a Farmer and a Blacksmith, and run one turn of a bartering negotiation.”

4. Ask: `STATE?`

5. Type `SIM_OFF`.

If the AI ever drifts, just paste the rules block again and type `RESET`.

SIMULATION RULES

- Roles: [Define roles and their goals]

- State: [Define resources and variables to track]

- Commands: SIM_ON, SIM_OFF, RESET, STATE?

- Guardrails: Do not use out-of-sim context. If rules conflict, ask for clarification.

Here are my results from ChatGpt.

Don’t Let the Whiteboard Magic Die

It’s one of the best feelings in creative work. The whiteboard is a beautiful mess of boxes, arrows, and ideas. For a moment, the complex system you’re designing feels alive.

Then, you step back.

You snap a photo, and that living, breathing system flattens into a static jpeg. The magic dissipates, the momentum is lost, and the idea now faces a six-week engineering sprint just to build a prototype.

But what if you didn’t have to let that energy die? What if you could take the logic from that whiteboard and bring it to life in the next sixty seconds? That’s what I’ve started doing. I’m using a simple chat interface to extend that creative session, turning the whiteboard’s static blueprint into a dynamic, playable world.

The Simulation Protocol

This is the repeatable system I use to turn ideas into interactive models. It’s built around a canonical set of rules that you teach the AI once.

Step 1: Define the Rules (Iteratively)

I never try to get the rules perfect in one go. I start with a simple core and build on it conversationally. The goal is to populate a master ruleset that you can reuse and refine.

Here is a more detailed Canonical Rules scaffold you can adapt. I keep this in a separate text file.

SIMULATION RULES 

- Roles: You are a [Role A]. I am a [Role B].

- State: Track these variables: [e.g., Resources, Health, Project Status]

- Turn Loop: [e.g., I take an action, then you resolve the turn.]

- Resolution Rules: [e.g., If X happens, then Y is the outcome.]

- Commands: SIM_ON, SIM_OFF, RESET, STATE?

- Guardrails: Do not use out-of-sim context. If a rule is ambiguous, ask for clarification.

Step 2: Run and Interact

Once the simulation is on, the interaction pattern can take many forms, depending on what you’re modeling.

• Conversational Role-Play: You simply play your role, and the AI responds as its designated character.

• Menu-Based Choices: The AI presents a menu of options (`1. Build, 2. Train, 3. Research`), and you reply with your choice.

• Direct Commands: You use simple commands like `ADD 10 GOLD` to test a specific mechanic.

The key is that everyone plays their part according to the rules you defined.

---

Boundary Control: The Key to Reliable Simulations

This is the one habit that keeps simulations honest and effective. To keep the simulation world separate from our real-world chat, I use a few simple commands you’ve already seen.

The most important are `SIM_ON` to enter the simulation and `SIM_OFF` to exit. Why is this so critical? To prevent a problem I call Context Bleed.

Context Bleed is what happens when the AI uses information from outside the simulation’s defined reality, breaking the integrity of the test.

Just recently, I was simulating a first-time conversation between a non-technical founder persona (”Mike”) and an AI co-founder persona (”Max”). Max, the AI, enthusiastically greeted Mike and immediately started talking about building their “Video Prompt Generator.” The problem? Mike hadn’t actually mentioned the project’s name yet. The AI had “cheated” by peeking at my project notes, breaking the realism.

The `SIM_ON` / `SIM_OFF` commands create a hard boundary. When the simulation is on, the AI knows to only use in-world information. If the simulation ever gets confused or you want to start fresh with updated rules, you use `RESET`. And to get a clean summary of all the important variables at any time, you use `STATE?`. These commands are your control panel.

Real-World Example: De-Risking a Company Pivot

So, the protocol is simple. But does it work for something that actually matters?

Absolutely. This is the exact technique I used to de-risk a major pivot for my company, Segmnts.

The big idea was to build a “Conversational OS,” a new way for teams to manage work. But that was a massive, company-defining bet. Asking a product owner, “Hey, would you use this?” would only get us a polite, hypothetical answer. We needed to test their behavior, not their opinion.

So, I ran a simulation. I had a real Product Owner play the role of “Boris,” who was tasked with running a one-week project. I gave the AI its role: “You are the three people on Boris’s team. When I give you Boris’s end-of-day update, you will provide me with plausible, realistic updates from each of them.”

The magic happened on Day 3. Boris submitted his update. The AI, playing his developer Anna, responded with a classic dose of reality:

`SIM_ON`

Boris: End of Day 3 update. My tasks are complete. I’m now waiting for the backend APIs to be ready so I can test the full user flow.

Anna (AI): End of Day 3 update. The backend logic for user authentication is more complex than we thought. I’m running about a day behind schedule. The APIs won’t be ready tomorrow morning.

Boris: Acknowledged. What’s the new ETA? Can anyone else on the team help you?

`SIM_OFF`

This wasn’t a bug in the simulation; it was the entire point. Boris wasn’t just testing an interface; he was actively managing a project with realistic friction. We got to see how he reacted, how he used the information, and what he did next.

That single, simulated interaction saved us an estimated three months of building the wrong thing. It didn’t just give us feedback; it gave us the conviction to change the direction of the entire company.

Your Turn: Run a 5-Minute Simulation

The best way to understand this is to try it. A quick heads-up: For these simulations to work, you’ll need a powerful reasoning model like GPT-5 or Gemini 2.5 Pro to handle the context and personas reliably.

Choose one of the challenges below that best fits the kind of problem you solve every day.

Challenge A: For Strategists & Planners

(Best for testing business plans, marketing campaigns, or feature rollouts)

This challenge tests your strategic plans against a council of critical AI personas.

1. Set the Scene: Copy and paste the following prompt into your chat AI:

 Let’s run a simulation. You are a Red Team Council:

 - Valerie (CFO): budget/ROI/resource risk

 - Marcus (Lead Engineer): feasibility/scope/failure points

 - Brenda (Marketing): market fit/message/reputation

 Facilitate in rounds: each persona critiques, then I will respond. Use concise bullets.

 SIM_ON when I say so; ignore out-of-sim context.

 Acknowledge if rules/rules conflict and ask to clarify.

2. Start the Simulation: Once the AI confirms, type `SIM_ON`, present your plan, and defend it.

Pro-Tip: Don’t just accept the AI’s first answer. Push back. Argue with Valerie the CFO. Ask Marcus the Engineer for alternatives. The goal is to stress-test your thinking, not just present it.

Challenge B: For System Designers & Creatives

(Best for testing game mechanics, user flows, or rule-based systems)

This challenge uses the AI as a game engine to bring a simple card game to life.

1. Set the Scene: Copy and paste the following prompt into your chat AI:

 You are a deterministic turn-based Game Engine.

 Canon:

 - Card: {name, cost, atk, hp}

 - Combat: both units strike simultaneously each turn.

 - Log: Turn #, Actions, Resulting HP.

 - State only changes via declared rules.

 Commands: SIM_ON, SIM_OFF, STATE?, RESET.

2. Define Your Cards: Once the AI confirms, invent two simple cards (e.g., ”My first card is Stone Golem: Cost 3, Atk 2, HP 5.”).

3. Start the Simulation: Type `SIM_ON` and command the engine: ”Stone Golem fights Fire Imp. What happens?”

Pro-Tip: Let the AI scaffold multiple cards.

---

FAQ & Troubleshooting

• What if the AI invents facts or “leaks” context?

  • Correct it directly: ”That’s out-of-sim context. Use only in-world info.” Then use `RESET` to get a clean slate with your canonical rules.

• What if the AI seems to forget the state?

  • Use the `STATE?` command. This forces the model to re-emit the current state as a clean block, reminding both of you what’s true.

• What if the AI is too verbose?

  • Add a rule to your canonical set: ”Responses must be 3 sentences or less unless I ask for more detail.”

What did you simulate?

Share your experiments and what you learned in the comments below.

Keep Reading

Cognitive Dissonance Debt Is Killing Your AI Strategy