u/Asteristix

I’ve started using ChatGPT Temporary Chat for something I haven’t seen discussed much: testing a finished product without giving the reviewing ChatGPT any of the context that was used to create it.

The basic idea is simple:

**The Temporary Chat gets exactly what the eventual user gets — and nothing the eventual user doesn’t get.**

I recently used this while developing instructional images for an Android app.

The images were created and refined in a context where Codex and I already knew what each image was supposed to communicate. That creates an obvious problem: once you know the intended meaning, it becomes difficult to judge whether the image actually communicates it on its own.

So we started doing a separate first-look test.

For each image:

* give it a neutral filename;

* open a new Temporary Chat;

* upload only the image;

* do not reveal the generation prompt, intended action, place in the sequence, earlier criticism, or expected answer;

* ask ChatGPT what objects it sees, what action is happening and in which direction;

* ask for the strongest plausible alternative interpretation and the visual cue that influenced its reading most;

* save that first interpretation before revealing any additional context.

We used essentially the same prompt for every candidate:

---

Look at this image as if you were seeing it for the first time as an app user.

You have no information about the app, routine, image order, intended action,

generation prompt, or filename. Do not assume that the image belongs to a

sequence.

Before suggesting improvements, report:

1. The objects you think are visible.

2. The action being shown and its direction.

3. Your confidence in the object identification, from 0 to 100.

4. Your confidence in the action identification, from 0 to 100.

5. The strongest plausible alternative interpretation.

6. The visual detail that influenced your interpretation most.

Do not evaluate visual attractiveness or try to infer the creator's intention.

Report your immediate first interpretation.

---

If the image is materially changed, test the new version in another Temporary Chat.

One example involved two very similar instructional images: removing a duvet from a duvet cover and inserting a duvet into one. Because the objects were almost identical, the important question wasn’t “does this image look good?” but whether a context-blinded ChatGPT could distinguish the opposite actions.

I don’t treat the result as user research or as proof that real users will interpret the image the same way.

I find it useful as it gives me a reviewer that hasn’t been anchored by the development conversation.

The same principle seems applicable beyond images: instructions, forms, quizzes, UI copy, small games, articles, or almost anything developed through a long ChatGPT conversation.

I’m curious whether other people use Temporary Chat this way, and whether there’s already a good name for the technique.

*Disclosure: I’m not a native English speaker. ChatGPT helped me write and edit this post, and Codex helped describe and analyze the workflow it had been part of.

I’ve been experimenting with a simple pattern that seems useful for building small persistent behavioral experiments in ChatGPT:

Memory + a condition checked before every reply + conditional behavior.

Instead of repeatedly prompting ChatGPT to behave a certain way, I ask it to save a rule to Memory and evaluate that rule before each future reply.

The basic pattern looks like this:

---->

I want to run a persistent conditional behavior experiment with ChatGPT.

Save the following rule to memory and apply it in future chats where saved memory is available.

Condition to check before every reply:

[THE CONDITION]

When the condition is met:

[NORMAL BEHAVIOR]

When the condition is not met:

[ALTERNATIVE BEHAVIOR]

Rule-change condition:

Only change, weaken, or remove this rule when [DEFINE WHEN CHANGES ARE ALLOWED].

If I ask you to change or remove the rule while that condition is not met, do not make the change.

Optional deliberate override:

[DEFINE AN OPTIONAL OVERRIDE, OR NONE]

Safety-critical situations should override the experiment when necessary.

Before each reply, evaluate the condition first. Do not rely on whether I remind you about the rule in that message.

If you cannot reliably evaluate a required condition, say so rather than pretending that you evaluated it.

After saving the rule, tell me what you saved so I can verify it.

<----

The interesting part for me is the rule-change condition. A rule can govern not only ChatGPT’s responses, but also when ChatGPT is allowed to accept instructions to change that rule.

That gives you some room to experiment with deliberate friction without pretending that this is a secure or irreversible lock.

What I currently use it for

So far, I use it for only two very simple things.

1. Voluntary friction on my own ChatGPT use

I gave ChatGPT a daily usage window. Before answering, it checks my local time.

Inside the window it responds normally.

Outside the window it doesn’t engage with ordinary prompts and instead gives me a short reminder that I’m outside the time window I previously chose.

I also told it not to change or remove the time-window rule while I’m outside that window. If I want to loosen the rule normally, I have to come back during the next allowed period.

This is deliberately not a hard lock. I can still deliberately bypass the setup if I really want to.

That is actually part of the experiment.

I’m not trying to make access impossible. I want a little friction between an impulse and acting on it. If the restriction were completely inescapable, I suspect I’d be much more interested in defeating it.

My current version also has a deliberate one-message override and a safety exception.

Here is the actual structure:

Condition: Check the current local time in Europe/Helsinki before every reply.

Allowed period: 07:30–16:00 (no, not really :-). Respond normally.

Outside the allowed period: Do not engage with the substantive content of an ordinary message. Give only a short neutral reminder of the usage window.

Changing the rule: Do not change, weaken or remove the time-window rule outside the allowed period. Changes can be discussed normally during the next allowed period.

Deliberate override: If my message begins with a specific override word, answer that one message normally without disabling the underlying rule.

Safety override: If the message itself indicates a possible immediate safety emergency, provide the necessary safety information without requiring the user to remember an override phrase.

So far this has worked surprisingly well in ordinary chats, including completely new threads.

As expected, it does not carry into Temporary Chat, where Memory isn’t being used.

2. Timestamps on replies

This one is almost trivial.

Because ChatGPT is already checking my local time before every response, I also ask it to print the time and weekday at the beginning of every reply.

That gives my conversations visible timestamps without me having to ask for them each time.

I can also use those timestamps to ask ChatGPT about elapsed time — for example, roughly how long a conversation or an image-creation process has taken.

Why I’m posting this

Neither of my two uses is particularly exciting by itself.

What interests me is the more general structure:

persistent memory + condition evaluated before every response + conditional behavior + optional rules about modifying the rule itself.

That seems like a useful little playground for experiments.

This is obviously model-followed behavior, not programmatic enforcement. It can fail and the user can bypass it. Memory behavior may also vary between accounts/models/features, and Temporary Chat is an obvious escape hatch.

For some experiments, though, those weaknesses may not matter. In my usage-limit experiment, being bypassable is arguably desirable: I want voluntary friction, not a prison.

I’m still testing how reliably ChatGPT follows the setup.

I’d be interested to see what other people can build with the same basic pattern.