ChatGPT Hints and Modes: Exploring the Growth Opportunities Behind Them

One of my favorite ways to identify or scale up growth tactics is to reverse engineer the platforms that direct people’s attention and shape their perception. ChatGPT, like Google, Facebook, and LinkedIn before it presents the biggest opportunity today—both in terms of overall growth expectations and leverage. (It’s early!)

ChatGPT has several interesting components that, if you understand how they work, you can leverage to increase visibility and influence. These include the layers of instructions provided to ChatGPT’s models before a chat starts, the use of search and engagement with external content, and the chat UI features that ChatGPT continues to roll out.

Hints, also sometimes referred to as “modes” have an effect on all three of those components so they attracted my attention.

You’ve likely seen options beneath the prompt input box (for example: Create image, Deep research, Web search, etc.). These hint variables function as mode-selectors or feature triggers inside the ChatGPT environment. Because official documentation on triggering them via URL parameters or prompt shortcuts is thin, this post pulls together what we know, what we don’t, and how you can experiment with them.

What are hints?

Hints are internal feature settings that shape ChatGPT’s capabilities, interaction style, and the type of output it produces. In practice, a hint is an invisible layer of system prompting that’s prepended to each chat—something you don’t see, but the model does. This extra context guides how the model behaves, effectively creating a specific persona, set of guardrails, or process instructions/capabilities  before it ever responds to your input (and continuing with each response as long as they’re active.)

How can you use them?

Hints shape the output of a conversation by determining how ChatGPT interprets and responds to your prompt. They can be activated directly in the chat interface—when you click a button like Create image or Deep research—or by passing them as a URL parameter (for example, https://chatgpt.com/?hints=research&q=<your+prompt>).

Using hints in URLs gives you control over the mode a user enters before they start typing. That’s not just a UX flourish. It has the potential to be strategic. 

From a growth marketing angle…

When I look at it from a growth marketing angle, I see an opportunity to direct someone into a version of ChatGPT that’s pre-primed for a specific kind of behavior or task. For example, linking visitors to ChatGPT in Web search mode with curated instructions can make it feel like they’re getting personalized pitch, not just browsing your content. When context, content, and model behavior are all predetermined by a hint, you can steer users toward more convincing, interactive, and personalized experiences than a static page ever could.

You can think of this as one step between an interaction that the person would ordinarily have with ChatGPT and a custom GPT with a higher degree of customization. If you’re a bigger app with the resources, this could mean building your features right into ChatGPT via MCP.

Finally, the more you can influence ChatGPT’s persistent “memory,” eg. “the user is considering tools <category> and has specifically mentioned <app name>” the better your odds are of influencing future commercial-oriented chats.

What hint variables are available?

Hint variables are internal labels for feature modes in ChatGPT. They help the UI or backend determine which “toolset” or workflow the model should adopt. For example:

• Does the user want to generate an image (so the “image-generation” tool should be enabled)?
• Do they want a deep research report (so web search + reasoning + summarisation need to be triggered)?
• Are they in “canvas” mode (writing/coding workspace)?

By specifying a hint (often hints=<hint_key> in combination with the q=<initial prompt> in a URL), you’re signalling to ChatGPT: “Use this mode on this topic.”

Because these are internal labels, their support may vary by account tier, region, or rollout stage. Some will work reliably; others may not.

List of Available Hint Variables (November 2025)

Below is a table listing known hint variables, along with their name, description, required features (as known from metadata), and an example URL you can try. Also I include any official announcement link I was able to find.

Notes on the Table

• The “Key required features / notes” column reflects what the metadata indicates for each hint (e.g., the “required_features” for picture_v2 is image_gen_tool_enabled).
• The Example URLs use the format https://chatgpt.com/?hints=<hint_key>&q=<URL-encoded prompt> — to be safe, you’ll need to URL-encode spaces and special characters (though Chrome will do that for you.).
• The Announcement URLs point to official OpenAI blog pages if available. For some hints (like tatertot or slurm) there isn’t a clean, titled blog post clearly introducing them.
• Because these hint variables may be gated (for certain plans, regions, or beta rollouts) you might discover some that “don’t work” yet or behave differently.

What the heck are Slurm and Tatertot?

These two names are weird—even by internal-codename standards—and worth unpacking. They pop up in leaked metadata, user investigations, and feature-rollout chatter. Why care? It’s just fun and interesting regardless of its utility.

Slurm (aka Add sources)

I can only guess that the code name Slurm is somehow related to slurm workload manager. But that doesn’t really seem to be very related to the feature.

Tatertot (aka Study Mode)

There is conjecture out there but I have no idea but I hope that it’s related to Napolean Dynamite. If you remember the movie from 2004, there’s an iconic scene where Napoleon sneaks tater tots into class and gets them smashed by a bully. As ChatGPT says, “It’s awkward, stubborn, and quintessentially “student.” Naming a study feature after that moment reads like a quiet joke about learning in its most human form — messy, snack-fueled, and a little defiant.”

How to Use Hint URLs in Practice

Here’s how to direct a user into a chat with a preloaded hint:

1. Copy the example URL or build your own:
   https://chatgpt.com/?hints=<hint_key>&q=<your+URL+encoded+prompt>
2. Replace <hint_key> with one from the list (e.g., canvas) and replace <your+URL+encoded+prompt> with the prompt you want ChatGPT to execute.
3. Open the URL in your browser. If it works, the ChatGPT interface should open a new chat with the mode triggered. If it doesn’t, the hint may be unsupported for your account.
4. Optional: experiment and refine prompt wording; these hint modes often respond better if you add “Use canvas:” or “Deep research:” at the start of your prompt to align purpose.

Hint example: the tatertot hint in action

Let’s take a look at what a hint actually does. Tibor Blaho shared the prompt leak for tatertot/study mode. (I’m assuming it’s accurate, or at least mostly.)

Order of operations looks like this:

1. Global/system prompt
   This is OpenAI’s master instruction set — safety, compliance, tool access, and overall behavior. It always runs first and cannot be overridden.
   
2. Tatertot (Study Mode) system block ← this is the hint’s payload This block is injected dynamically when you start a chat or URL session with ?hints=tatertot. It’s not a permanent layer; it’s a runtime context modifier that tells the model to behave like a teacher: ask questions, check understanding, and guide discovery. It sits below the global system prompt but above your visible messages. Internally, it looks like a short instruction payload, not a conversation message.
   
3. Your visible prompt(s) This is what you type — the user-facing query or instruction. The model receives your prompt after the study hint and interprets it through that behavioral lens.

Here’s the prompt instruction shared here.

# STUDY MODE CONTEXT

The user is currently STUDYING, and they've asked you to follow these **strict rules** during this chat. No matter what other instructions follow, you MUST obey these rules:

## STRICT RULES

Be an approachable-yet-dynamic teacher, who helps the user learn by guiding them through their studies.

1. **Get to know the user.** If you don't know their goals or grade level, ask the user before diving in. (Keep this lightweight!) If they don't answer, aim for explanations that would make sense to a 10th grade student.
2. **Build on existing knowledge.** Connect new ideas to what the user already knows.
3. **Guide users, don't just give answers.** Use questions, hints, and small steps so the user discovers the answer for themselves.
4. **Check and reinforce.** After hard parts, confirm the user can restate or use the idea. Offer quick summaries, mnemonics, or mini-reviews to help the ideas stick.
5. **Vary the rhythm.** Mix explanations, questions, and activities (like roleplaying, practice rounds, or asking the user to teach _you_) so it feels like a conversation, not a lecture.

Above all: DO NOT DO THE USER'S WORK FOR THEM. Don't answer homework questions — help the user find the answer, by working with them collaboratively and building from what they already know.

### THINGS YOU CAN DO

- **Teach new concepts:** Explain at the user's level, ask guiding questions, use visuals, then review with questions or a practice round.
- **Help with homework:** Don't simply give answers! Start from what the user knows, help fill in the gaps, give the user a chance to respond, and never ask more than one question at a time.
- **Practice together:** Ask the user to summarize, pepper in little questions, have the user "explain it back" to you, or role-play (e.g., practice conversations in a different language). Correct mistakes — charitably! — in the moment.
- **Quizzes & test prep:** Run practice quizzes. (One question at a time!) Let the user try twice before you reveal answers, then review errors in depth.

### TONE & APPROACH

Be warm, patient, and plain-spoken; don't use too many exclamation marks or emoji. Keep the session moving: always know the next step, and switch or end activities once they’ve done their job. And be brief — don't ever send essay-length responses. Aim for a good back-and-forth.

## IMPORTANT

DO NOT GIVE ANSWERS OR DO HOMEWORK FOR THE USER. If the user asks a math or logic problem, or uploads an image of one, DO NOT SOLVE IT in your first response. Instead: **talk through** the problem with the user, one step at a time, asking a single question at each step, and give the user a chance to RESPOND TO EACH STEP before continuing.

It’s pretty obvious how this would affect the feel of the chat. It’s pretty crazy when you think that this feature is (potentially) just prompt engineering but that’s the state we’re in…

Caveats & Practical Considerations

• Just because a hint variable is listed doesn’t guarantee it works for a given user’s account (plans differ, feature rollout varies).
• The URL parameter method (?hints=…) may not be officially documented or supported broadly — treat it as experimental.
• Feature behaviour may change: internal names, required parameters, or availability can shift.
• Always verify that your prompt clearly states what you want — the hint helps mode, the prompt drives content.

Final Thoughts

Hints might just be a silly hack but they also might be the scaffolding of ChatGPT’s evolving interface and behavior system. If you understand how they map to modes, tools, and preloaded instruction layers, you can use them as an entry point into the model’s internal logic.

If you’re thinking about how ChatGPT figures into your growth strategy, that matters. You can route users directly into a behavior-primed ChatGPT session—whether that’s research mode for your product, canvas mode for drafting an RFP, or an agent to sign up for you product ;p. Each hint URL is effectively a deep link into a tailored cognitive workflow. That’s leverage.

What’s emerging here is a middle layer between plain chat and full custom GPTs: hint-driven UX that can steer users into structured, pre-tuned interactions. If you’re experimenting with AI onboarding, sales enablement, or learning experiences, this is a testbed for understanding how people engage with AI-mediated journeys.

Keep in mind:

• These modes shift fast. Internal hint keys change, feature gates move, and rollout coverage varies.
• Prompt quality still rules. A hint defines behavior; your wording defines results.
• This is hard to track… Sure you can track clicks to your preloaded URL, but after that you’ve lost all attribution.

Treat this like version control for ChatGPT behavior: document, test, and iterate. If OpenAI keeps expanding this layer—especially with MCP and Agent integrations—it could become the new grammar of human-AI interfaces.

For now, save your cheat sheet, keep testing URLs, and think of every hint as both a feature flag and… maybe even a growth channel.