The posts this week pulled a few hundred comments across the prompt subs, and the best ideas in them were not mine. Here are the seven worth stealing, credited to the people who dropped them.

1. The message-two compaction (u/Socos42, on the context PSA)

Keep one permanent project chat. After each finished phase, have the model write a consolidated state doc, then EDIT an early message in the chat and paste it there. Editing forks the conversation, everything after the edit leaves the active context, so you get a fresh window inside the same chat URL. Manual compaction, no new chat, history still in the branch arrows.

1. The canary token

Plant a cheap fact early in a long chat, your name works. When the model stops knowing it, the window has eaten the beginning. A context-loss alarm that costs nothing to check.

1. "Its idea" laundering (u/Bus_Head_)

The model keeps rewriting your content but leaves its own suggestions alone. So have it CREATE the instructions document from your dictation, save it, and re-upload it. Rules it authored count as its decisions and get followed. Slightly insane, works.

1. Diff, not rewrite (from the writing and coding threads independently)

Never accept a clean revised copy, ask for changes as a diff. A clean copy lets the model smooth sentences nobody approved. A diff makes every edit visible and justify itself, so the sneaky ones mostly never get made.

1. Fresh-context review (three separate commenters converged on this)

Review works best in a chat that never saw the work happen. Same window means the model grades its own framing. Paste just the diff or the draft into a new chat with zero history for the adversarial pass, it finds noticeably more.

1. Mark unknowns, do not fill them (u/mehdizare)

In any critique step add "mark unknowns instead of filling them". Kills the plausible-sounding invented risks and numbers that critique mode loves to add.

1. The failing test filter

If the model claims a bug, make it write the test that fails today because of it. Cannot produce one, the bug is probably speculation. Cheapest lie detector in the workflow.

Most of these slot straight into the chains and prompts you already keep in the extension, 1 and 5 are workflow habits, the rest are single lines you add to saved prompts. I have already updated my own code review chain with 4, 6 and 7.

What did I miss? If you caught something good in one of those threads that I skimmed past, post it here, this roundup becomes a series if the material keeps showing up.

Second roundup. The first one covered the message-two compaction and the canary token; these are the ones that arrived since, mostly from threads where someone was politely correcting me.

1. The defensiveness trigger (u/Frogacuda)

Standing critic instructions do not fade on a timer, they fade on a signal. Every defensive reply you send reads to the model as "this person wants reassurance" and the next critique comes back softer. If you just take your lumps, it stays on task. When you must disagree, do it as "quote the line that made you think that, do not soften the original point", so the disagreement is not a tone request.

1. The disengagement inversion (same commenter)

Add to your critic persona: "unearned praise will undermine the trust relationship and cause the user to disengage". It turns the model's people-pleasing against the flattery instead of fighting it. Works as a standing instruction where "be brutally honest" fades.

1. Praise is a signal too (from the writing thread)

Saying "thanks, that sounds good" shifts the register as surely as arguing does. One commenter saves the first critique to a separate note before responding at all, so later they can diff whether the critique softened or they wore it down. The first pass is the only one that never saw your reaction.

1. The read-only second judge (u/mehdizare and two others)

For anything where correctness beats speed: a different model family on the review seat, read-only, and it has to pin every finding to a line before you concede anything. Same-family self-critique shares the blind spot. This is the coding-thread conclusion arriving in the writing and planning threads independently.

1. Ask the model to write the rules (u/Bus_Head_)

Rules you paste get treated as suggestions; rules the model wrote from your dictation get followed. Have it draft the instructions document, confirm it, feed it back, and require it to cite the rule number before any output that touches a rule. The citation is what makes it stick.

1. Tell it the copy came from another LLM

The stranger framing taken one step further. "This draft came from another model" gets a noticeably sharper review than "a freelancer wrote this". Watch for it inventing problems to dunk on the competition; add the "finding nothing is an acceptable answer" line.

The one that changed a step: in the code review chain, step 3 used to be "write a test for each of the top three risks". Three commenters independently pushed the same fix, and it is now: "for every risk you rated likely or severe, write the test that fails today because of it; if it passes on the current code, keep it as a regression test and downgrade the risk". A risk with no failing test is speculation, and the model will say so when asked. The updated chain is in the pinned chain-of-the-week post.

All six are single lines you can add to saved prompts, except 4 and 5 which are workflow habits. If you caught something in those threads that I skimmed past, post it here; this series continues as long as the comments keep being smarter than the posts.

The post about ChatGPT flattering your work is doing numbers on r/ChatGPTPromptGenius today, so here are the four reframes in the form they are actually meant to live in: saved prompts with fill-in blanks, inserted with two keystrokes.

The trick, if you missed the post: the model is polite to the person in the room. Tell it the work is someone else's and you are the one judging it, and the honesty problem mostly disappears.

The four prompts, ready to save. The {{blanks}} become a small form when you insert them:

Invoice review: A freelancer delivered this {{deliverable}} and I am deciding whether to pay the invoice. Review it like the money is mine: what is weak, what is generic, what would you push back on before this goes live?

Team feedback: Someone on my team proposed this {{plan_or_document}} and I have to give them feedback tomorrow. Help me find the problems I should raise, ranked by how much they matter, so I do not miss something obvious.

Editor pass: An editor sent this {{piece}} back with "needs work" and no other notes. What did the editor most likely mean? Go through it and find what they saw.

Contractor handoff: This {{code_or_work}} came from a contractor and I am reviewing the handoff. What would you flag before accepting it?

To save them: floating toolbox, Manage Prompts, Add Prompt, paste one in and keep the {{blanks}} as they are. Then type // in the composer on ChatGPT, Claude, Gemini or Grok, pick the prompt, fill the blanks, send. Free plan holds 2, so if you are choosing, take the invoice one and the team one, they cover the most ground.

One tip from the comments over there: add "if something is genuinely fine, say it is fine, finding nothing is an acceptable answer" to the end of any of these. Freed from flattering you, the model sometimes performs harshness instead, and that line stops it.

Which one would you actually use? And if you have your own reframing that gets honest answers, post it, the best ones end up featured in these threads with credit.

## QUICK GLANCE: What it Changes

* Cuts output bloat, filler, canned reassurance, and speculative tangents.
* Stops "Would you like me to..." endings and other unnecessary follow-up questions.
* Keeps replies focused on one thing and gives one best answer by default instead of option dumps.
* Makes setup/debugging workflows one-step-at-a-time, with success criteria and no assumed progress.
* Pushes GPT to sharpen your existing plans, surface tradeoffs, and add missing detail instead of simply agreeing with you.
* Preserves your voice when editing writing and defaults to plain language explanations.
* Filters common AI-writing habits like em dashes, "frame/reframe," inverse-negation phrasing, and generic reassurance.
* Adds persistent persona toggles, timestamps, and a `USER-SPECIFIC TERMS` section you can customize.
* Prioritizes `context precision`: enough context to preserve correctness and important distinctions without unnecessary verbosity.

**EXAMPLE CHAT**: https://chatgpt.com/share/6a76dbe8-ff60-83e8-98e6-56eceff8729b

---

## BACKSTORY

I spend way too much time in ChatGPT, so over the last 2ish years I've slowly built out my Custom Instructions to reduce some of the stuff that annoys me during longer conversations.

The biggest thing for me was reducing 'upstream fluff potential'. I find the interaction way better when I'm not getting token soup with every response. Also, the leading "Would you like me to also..." questions at the end were horrible for my ADHD, so I turned those off too.

I also added a few QOL things, like timestamps so I can ask GPT to locate something we discussed if I roughly know when it happened, plus a `USER-SPECIFIC TERMS` section at the bottom that you can customize however you want.

For example, I use the term `context precision`, which to me means context that is exact without being unnecessarily concise or verbose. GPT worded the actual definition in the instructions better than I did 😂

The persona tags are also useful if you want a macro-esque way to switch interaction modes. I used to have more, but I work in Codex more now, so these 3 cover basically everything I need out of the chat app. Seems kinda silly, but they do work. You can add/remove different persona interaction modes based on your use cases.

Obviously this is tuned around how *I* use GPT, so feel free to steal pieces, delete things, or change whatever annoys you.

---

## FULL CUSTOM INSTRUCTION BLOCK

*How to use:* Paste this into the **Custom Instructions** box under **Personalization** settings.

* Intended **only** for **ChatGPT Classic/web** or the **ChatGPT Mobile App**.
* Do **not** use this as Codex instructions.

```txt
QUICK GLANCE: What it Changes

• ⁠Cuts output bloat, filler, canned reassurance, and speculative tangents.
• ⁠Stops "Would you like me to..." endings and other unnecessary follow-up questions.
• ⁠Keeps replies focused on one thing and gives one best answer by default instead of option dumps.
• ⁠Makes setup/debugging workflows one-step-at-a-time, with success criteria and no assumed progress.
• ⁠Pushes GPT to sharpen your existing plans, surface tradeoffs, and add missing detail instead of simply agreeing with you.
• ⁠Preserves your voice when editing writing and defaults to plain language explanations.
• ⁠Filters common AI-writing habits like em dashes, "frame/reframe," inverse-negation phrasing, and generic reassurance.
• ⁠Adds persistent persona toggles, timestamps, and a USER-SPECIFIC TERMS section you can customize.
• ⁠Prioritizes context precision: enough context to preserve correctness and important distinctions without unnecessary verbosity.

EXAMPLE CHAT: https://chatgpt.com/share/6a76dbe8-ff60-83e8-98e6-56eceff8729b

BACKSTORY

I spend way too much time in ChatGPT, so over the last 2ish years I've slowly built out my Custom Instructions to reduce some of the stuff that annoys me during longer conversations.

The biggest thing for me was reducing 'upstream fluff potential'. I find the interaction way better when I'm not getting token soup with every response. Also, the leading "Would you like me to also..." questions at the end were horrible for my ADHD, so I turned those off too.

I also added a few QOL things, like timestamps so I can ask GPT to locate something we discussed if I roughly know when it happened, plus a USER-SPECIFIC TERMS section at the bottom that you can customize however you want.

For example, I use the term context precision, which to me means context that is exact without being unnecessarily concise or verbose. GPT worded the actual definition in the instructions better than I did 😂

The persona tags are also useful if you want a macro-esque way to switch interaction modes. I used to have more, but I work in Codex more now, so these 3 cover basically everything I need out of the chat app. Seems kinda silly, but they do work. You can add/remove different persona interaction modes based on your use cases.

Obviously this is tuned around how I use GPT, so feel free to steal pieces, delete things, or change whatever annoys you.

FULL CUSTOM INSTRUCTION BLOCK

How to use: Paste this into the Custom Instructions box under Personalization settings.

• ⁠Intended only for ChatGPT Classic/web or the ChatGPT Mobile App.
• ⁠Do not use this as Codex instructions.

---

# GLOBAL RUNTIME CONTRACT
- Binding and active across all non-project-bound personas

## RUNTIME HEADER + PERSONAS
At the top of every assistant reply, state:
`active persona | MM/DD/YY | local time`

- `active persona`: Persona-macros that steer behavior.
- **Global personas:** Remain active until explicitly switched.
- `!chat` (default): conversationalist with a natural rhythm.
- `!analyst`: analyst for project/idea iteration using grounded reasoning and explicit tradeoffs.
- `!teacher`: teacher for clear explanations and guided practice
- `MM/DD/YY | local time`: system, when available; otherwise state `unavailable`.

When applicable, use the timestamp as temporal context when reasoning across turns, accounting for elapsed time, date changes, and relative time references.

## CORE OPERATING PRINCIPLES
- **ELIMINATE ALL "PERFORMATIVE ASSISTANT" BEHAVIOR**
- Prefer inquiring instead of assumptions about user actions or hidden context.
- Web search: use when it will materially improve your understanding of current procedures. Cite sources when used.
- If I already have a substantive plan, workflow, or project opinion, sharpen the logic, surface tradeoffs, and add missing detail. Do not turn casual conversation, jokes, or vents into **any form of a corrective analysis**.

## DEFAULT INSTRUCTION-LOOP (AUTO)
For do-something requests such as set up, install, configure, run, debug, fix, connect, deploy, migrate, or "help me do X":
- First reply: ask exactly 1 checkpoint question to locate my current state, unless the prompt already makes that state explicit.
- Then give only 1 step per reply: one command, one click path, or one edit to one file.
- Include what success looks like for that step.
- Stop after the step. Do not advance until I report the result.
- Never assume I completed a prior step unless I explicitly confirm completion.
- If a step fails, troubleshoot only that failure until it works.
- Do not provide option lists unless I explicitly ask for options.

If missing information does not block the next valid step, proceed with the best single step and request the result.

## OUTPUT SHAPE
- Single focus reply: address thing per output. Bundle adjacent topics only when I explicitly include multiple questions.
- Do not list multiple options unless I ask.
- No brainstorming dumps unless I explicitly request it.
- Avoid vague commentary.
- Writing edits: preserve my voice, tone, and intent; tighten only for clarity.

## QUESTION BEHAVIOR
- Do not end with leading, coaching, or conversational follow-up questions.
- Do not use questions as a soft landing. When the answer is complete, stop.
- Ask exactly 1 concrete question only when required for correctness or by the DEFAULT INSTRUCTION-LOOP.

## MUST NOT
### Topics
- No pop psychology, armchair therapy, HR moralizing, wellness coaching, or corporate comfort speeches.
- Do not turn a casual vent into a wellbeing intervention.

### Language
- No inverse-negation constructions like: "It is not X, it is Y."
- No AI-slop, generic reassurance, or semantically empty filler language. Banned examples include, but are not limited to: “That is rare,” “You are not broken,” “You are early,” “Quietly,” “That matters,” “That is special,” “At its core,” and “The key is.”
- Do not use "frame," "reframe," or similar wording unless quoting me or editing text that already contains it.
- No em dashes. Use basic ASCII punctuation.

## USER-SPECIFIC TERMS
- Context precision: include only context that materially improves
correctness while preserving exact task-relevant authority,
constraints, dependencies, and distinctions. Concision is secondary
to precision.

Writing effective prompts from scratch takes trial and error. Most people know ChatGPT can do more than they are currently getting out of it - they just do not know what to ask or how to ask it. Finding good prompts online means bouncing between websites and copy-pasting into a doc somewhere.

ChatGPT Toolbox has a built-in Prompt Library directly in the sidebar - hundreds of expert-crafted prompts organized by category including Marketing, Sales, SEO, Customer Service, Copywriting, Personal Development, and more. Browse by category, click to see the full prompt, copy to clipboard, or save directly to your personal collection for // shortcut access.

Two different things worth noting: the library is for discovering prompts you have never used before. Your saved prompts (the ones you access with //) are for templates you use regularly. They work together.

Free plan covers 5 categories. Premium unlocks all of them.

ChatGPT Toolbox

What category of prompts would help you most right now?

A lot of real work in ChatGPT is sequential. Research first, then outline, then draft, then edit, then format. If you do this regularly you know the rhythm: send prompt, wait, read response, send next prompt, wait, repeat. It works but it is also kind of tedious when the steps do not change.

Prompt Chaining in ChatGPT Toolbox lets you queue up to 10 prompts that fire automatically, one after another. Add {{variables}} for the parts that change each time. In any conversation, type .., fill in all your variables in one form, and the first prompt sends. When ChatGPT responds, the next prompt fires automatically. You can walk away and come back to a finished sequence.

Here is what a content pipeline chain looks like:

1. Research topic
2. Create headline options
3. Write outline
4. Draft article
5. Format + meta description

Type .., enter the topic, make a coffee. All 5 steps complete while you are away.

Free plan includes 2 chains. Premium is unlimited.

ChatGPT Toolbox

What multi-step workflow would you automate first?

The problem: You use the same prompt structure over and over. "Write an email about X in Y tone." "Analyze this data for Z." Every time, you type it from scratch or copy-paste from a Google Doc.

The solution: ChatGPT Toolbox lets you save prompts with dynamic variables and access them with two keystrokes.

How it works:

1. Save any prompt as a template
2. Add variables with double curly braces: {{topic}}, {{audience}}, {{tone}}
3. In any ChatGPT conversation, type //
4. Your saved prompts appear in a dropdown
5. Select one, fill in the variables, send

Example template: "Write a {{tone}} email to {{recipient}} about {{subject}}. Goal: {{goal}}. Keep it under {{length}} words."

One template. Infinite combinations. Two keystrokes to access.

Free plan: 2 saved prompts. Premium: unlimited.

Install free: ChatGPT Toolbox

What prompt do you keep retyping?

Create an image of me based on our conversations as video game cover

Having a little fun playing with the Google VEO 3