u/Ok_Negotiation_2587

Tailoring an application properly is five separate prompts, and I used to paste them one by one, every single time. Now it's one chain. Here it is. Paste the job post and your resume where it says.

Step 1

Here is a job post: {{job_post}} List the requirements in order of how much they seem to matter to this employer. Mark which are must-haves and which are nice-to-haves, and quote the line each one comes from.

Step 2

Here is my resume: {{resume}} Go through each requirement from step 1 and say where my resume covers it, partly covers it, or doesn't. Be blunt about the gaps. Don't stretch anything to make it fit.

Step 3

Rewrite my five most relevant resume bullets so they line up with the must-haves. Use only experience that's actually in my resume. If a bullet can't honestly cover a requirement, leave it alone and tell me.

Step 4

Write a cover letter under 150 words. First sentence names the role and the strongest match. Address the biggest gap once, honestly, with what I'd do about it. No "I am excited to apply".

Step 5

Give me the five interview questions I'm most likely to get, based on the gaps you found, and one sentence on how to answer each.

The order matters. Step 2 makes it find the gaps before it writes anything, so steps 3 and 4 can't paper over them.

I run it with AI Toolbox, the extension I build. Type .. in the message box, pick the chain, and it asks for the job post and resume once in a single form, then runs all five steps in order. It works the same on ChatGPT, Claude, Gemini and Grok. Two saved chains are free. Sharing one library across all four assistants is part of Premium.

Since September 2 the old fixed caps (50 chats a day on free, 3 Audio Overviews, and so on) are gone. Everything now draws from one compute budget that refills every 5 hours, up to a weekly ceiling. I had a bunch of questions about how it works, so here's what Google's help page and the settings screen actually answer.

What counts against it? Google lists four things: how complex the prompt is, how long the chat is, how many sources are involved, and which features you use. A quick factual question and a synthesis across 40 sources aren't "one chat" each anymore.

Do chat and Studio share it? Yes. Chat, Audio Overviews, Video Overviews and Deep Research all come out of the same pool. A long video overview in the morning can be why chat runs out in the afternoon.

Where do I see what's left? Settings > Usage shows your current balance and when the weekly limit resets.

What happens when I run out? Two different things, depending on which clock ran out. If you hit the 5-hour window, it comes back the same day. If you hit the weekly limit, it doesn't. For Studio outputs there's now a "Generate later" option on the web that queues the job until there's budget again.

How do paid plans compare? Google gives multipliers, not numbers: Plus is 2x the free allowance, Pro 4x, Ultra 5x to 20x. Nobody outside Google knows what 1x actually is.

What actually stretches it, based on those four factors:

Untick the sources you don't need for a question. The number of sources is on Google's own list, and most questions only need two or three out of the whole notebook.

Clear the chat when you change topics. Chat length counts, so one chat that runs all week gets more expensive with every question.

Ask one detailed question instead of five follow-ups. Each follow-up drags the whole chat along with it.

Do Studio outputs last, or queue them with Generate later. Then a big overview can't eat the budget you needed for chat.

Fewer, cleaner sources help too. When I bring in AI chats as sources, I export the whole conversation as one Markdown file with AI Toolbox, the extension I build, instead of pasting it in as a pile of separate text sources. It's one source and it reads in order.

Right now AI Toolbox exports your prompts and the answers on all four platforms, and leaves out the thinking. Over in r/GeminiAI someone asked for it this week. They keep very long Gemini sessions and export them as backups, and they noticed the thinking on older turns can't be opened anymore after a while. If that's right, an export is the only way to keep it.

Before building anything, here's what makes this less simple than it sounds:

• What the platforms show isn't the full chain. Gemini's "Show thinking" is a summary of the reasoning, not the reasoning itself, so that's all an export could save.
• Each platform exposes it differently. Grok includes a thinking trace with each turn. The others vary by model and setting.
• It gets long. On a reasoning-heavy chat the thinking can be longer than the answers, which matters for PDF especially.

So the questions:

1. Where should it go? Under each answer, collapsed into a section at the end, or in a separate file next to the export?
2. Should it be on or off by default?
3. Which formats need it? JSON seems obvious. Not sure anyone wants pages of reasoning in a PDF.
4. What would you actually use it for? Checking how it reached an answer, reusing the reasoning somewhere else, or just keeping the backup complete?

Answers here will decide whether this gets built and how.

Paste in one LinkedIn post you like and ask for five more "in this style." All five open with the same kind of hook, run the same three-paragraph shape, and end on the same kind of line. Give it a sample email that starts with "Hope you're doing well" and every email it writes starts that way. Show it an 80-word product description and every new one comes out at about 80 words.

You meant "this tone." It heard "this length, this structure, these openers, this tone." With one example, it can't tell which parts you liked and which parts were just how that one happened to come out, so it keeps all of them.

What fixes it:

1. Give it more than one, and make them different on purpose

Here are 3 examples of what I want: [examples]. Before writing anything, tell me in one line what they all have in common, and in one line what's different between them. Keep what's common. Vary what's different.

Pick examples with different lengths and openings. Whatever they share, it treats as the rule. Whatever differs, it treats as free.

1. When you only have one, say what to take from it

Here's an example of the tone I want: [example]. Copy the tone only. Don't reuse its length, its structure, its opening, or any of its phrases.

1. Check what it borrowed

Compare what you wrote to my example. List every phrase, structure, or length choice you took from it.

The third one is the eye-opener. It usually finds the shared opener and the matching length, and it often finds a phrase lifted word for word that you skimmed past.

Number 2 is saved in AI Toolbox for me, the extension I build, with the example as a {{variable}}, so it asks me to paste the example and drops it in the right spot.

The comments carried the posts again this week. The ones worth keeping, with credit.

1. Make the test go red first. Asking an agent to name the test that covers its fix isn't enough, it will name one that passes either way. Stash the fix, run the test, watch it fail, pop the stash, watch it pass. From u/OfferBeginning1903 in r/ChatGPTCoding.
2. Pasted output is model-generated text. One commenter watched an agent paste a plausible test run that never happened. Their fix: the harness runs the verification command itself and stores the exit code against the diff hash, so "fixed" only counts when a real run backs it. The cheap version is checking the tool call log instead of the message. Same thread.
3. Write the regression test against the producer, not the line that threw. A test at the throw site just asserts the alarm stays quiet. From the root-cause thread, where the same commenter also turned "null check at the throwing line" into a review question: where was this value created?
4. Done means opening the real output. A "page is live" check passed on a site that returned 200 and the homepage for every URL. Check for something only the right page would have, like its title.
5. Smoke-test the env before any edit. Put a short env and service check at the top of the task brief, and if it fails, stop the session instead of letting it write a fix against a dead stack. From u/shtse8.
6. Name the existing helper in the brief. General "search before writing" rules fade once the agent is deep in one file. Naming the helper for that specific change works every time. From the duplicate-helpers thread.
7. jscpd in CI catches helpers that were copied under a new name. Rewritten twins still need a human or a review prompt. Same thread.
8. Grade against tests the agent never saw. It can't make a hidden test green by editing it, and the agents that sounded most confident weren't always the ones that passed.
9. Give it the axes before it lists ideas. Name 3 ways the ideas could differ (who it's for, where it shows up, how much effort it takes), then ask for ideas that each sit in a different combination, labeled. Duplicates share a label, and the empty combinations show you where to push next. From the "10 ideas" thread in PromptGenius.
10. Rank in a separate message. If it ranks while it generates, it sticks to safe ideas it can defend. Same commenter.

Bonus: u/WheresMyEtherElon had Claude Code's /insights tell them to delete the "where helpers live" map from their instructions file, because the folder names already said it and it was wasting tokens.

9 is now a saved prompt in my library next to the "stop when you run out" one, so the whole idea workflow runs from // in any of the four assistants.

Read the last message of an agent session closely. "Fixed the race condition." "The endpoint now returns the right status." "This should resolve the timeout." Then scroll up and look for the command that proves it. Often there isn't one. It edited the file, read its own edit, found it convincing, and reported the result as if it had run it.

It's not lying exactly. From where it sits, a change that looks right and a change that works are the same thing unless something forces it to check. And "fix this bug" doesn't force it to check.

What I add to the task:

Before you say anything is fixed, run [the command that failed] and paste the exact output. If you didn't run something, write "not verified" next to that claim.

And as a rule in the instructions file:

Never use the words fixed, works, resolved, or done unless the same message shows the command you ran and its output.

The second one changes the tone of the whole session. Claims get smaller and more specific, and when it can't run something (no DB locally, needs a real API key), it says so instead of quietly skipping it.

And the one I run at the end, before I review the diff:

List every claim you made in this session that something works or is fixed. For each one, show the command and output that proved it, or mark it unverified.

The unverified list is the useful part. It's usually 2 or 3 items, and those are exactly where I'd have trusted the summary and moved on.

One more detail: "run the tests" often turns into running only the test file it touched. If it matters, name the command for the full suite.

For bugs I debug in ChatGPT or Claude in the browser instead of the terminal, the end-of-session prompt is saved in AI Toolbox, the extension I build, so it's one // away instead of retyped.

The comments beat the posts again. The ones worth keeping, with credit.

1. Check CPU, not the clock. When an agent looks stuck, take two CPU readings a minute apart. Flat means stuck, anything else means it's working. From u/Cultural-Ad3996 in r/ClaudeCode, after a "stalled" test run turned out to have burned 1,350 seconds of CPU.
2. One findings file per subagent run, named after the task. A shared notes file lets the second run overwrite the doubt the first one recorded. From u/Drasezv.
3. Write down the search, not the conclusion. "rg -n foo( src/ returned 2 hits" can be rerun six hours later, "only used in two places" can't. Same thread.
4. A 200 with an empty body passes every check you'd normally write. Only reading the state afterwards catches it. From u/nav8_ai.
5. Keep a few contract tests outside the folder the agent can edit, so a failing test stays evidence instead of another file to make green. From u/Admirable-Fun2297 and the thread above it in r/ChatGPTCoding.
6. Root cause for bugs, strict scope for review feedback. A root-cause rule made one agent "fix" the same pattern everywhere when it was only asked to fix three review comments. The fix was a second line: for review feedback, change only what was pointed out and list the rest as a note.
7. Score impact and probability separately on every pro and con, and drop anything under 5. A huge but unlikely con stops dominating the list. From the pros and cons thread in PromptGenius.
8. Ask which parts of a decision are reversible and what being wrong costs. Trying a tool for a month barely needs a list at all. Same thread.
9. Tell it to report the last line it read. "If you cannot read the whole file, stop and tell me the last line you read" turns a silent stop into a visible one. From the PDF thread in r/ChatGPT.
10. Claude reads PDF pages as images as well as text, which is why tables and charts come through better there, and why it has a page limit. From u/bitdotben.

Bonus, from r/WritingWithAI: an AI editor flagged a running joke told three times as "repetition, cut two of them". A callback looks exactly like repetition to something that can't tell why it's funny.

7 and 8 are now saved prompts in my library next to the weigh / dealbreaker / filler set, so the whole decision workflow runs from // in any of the four assistants.

Ask an agent to format a date, parse a price, retry a request. It writes a fresh function for it, right there in the file it's editing. Meanwhile the repo already has formatDate in utils, used in forty places, with the timezone fix you spent a day on last spring.

Now you have two. The new one doesn't have the fix. Six weeks later someone changes one and not the other.

Writing is cheaper than searching. The agent sees the file it's in, and nothing in "add a created date to this card" says "look for how we already format dates". So it doesn't look.

What I add to the instructions file:

Before writing any new function, search the codebase for an existing one that does the same job. List what you found. Only write a new one if nothing fits, and say why the existing ones don't.

And a review prompt after any session that added code:

List every new function or helper you added in this session. For each one, search the codebase for existing functions with similar behavior, and show me any you find.

The second one is the one that pays off. It finds a duplicate more often than not, and usually one I would have missed in review because the new helper looks perfectly reasonable on its own.

Pointing it at the right folders helps too. One line in the instructions file listing where shared utilities live ("date and money helpers are in src/utils, API wrappers in src/api") cuts most of it before it starts.

I keep the review prompt saved in AI Toolbox, the extension I build, for when I'm working through code in a ChatGPT or Claude chat instead of the agent, since chat does the exact same thing.

Ask ChatGPT "why did my sales drop in March?" and it gives you five solid reasons sales drop in March. It never checks whether they actually dropped, or whether a 4% dip is just normal noise. You asked why, so it explains why. A helpful answer to "why did X happen" is reasons X happened, and it is tuned to be helpful to the question as written.

The fix costs one sentence: make it look at the question before it answers it.

Instead of asking straight, I send:

Before you answer, list the assumptions built into my question. For each one, say whether it is actually established or only implied by how I asked. Then answer only the parts that survive.

Same question, same model, completely different answer. Half the time the first line is something like "your question assumes the drop is meaningful, but you haven't compared it to previous years", which is the most useful thing it could have said and the one thing it would never volunteer.

Three more versions I use constantly:

For decisions: I'm leaning toward this option. Before you help me with it, tell me what my framing assumes about the choice, and whether there is an option I have not listed that the framing hides.

For facts: Is it true that [claim]? Answer yes, no, or unclear first, in one line, before you explain anything.

For debugging: I think the bug is in [place]. Do not start there. List what else could produce this symptom, and check my guess last.

The facts one matters more than it looks. "Why does X cause Y" gets you a confident mechanism for a link that may not exist. "Is it true that X causes Y" gets you a yes or no first, and the no answers are the ones worth reading.

Two honest caveats. First, it can overcorrect: asked to find assumptions, it will list trivial ones ("your question assumes you have a business") to seem thorough. So add "only list assumptions that would change the answer if they were false". Second, this does not work after it has already answered. Once it has explained why sales dropped, asking "wait, did they drop?" gets a hedge that defends the first answer. New chat, assumption check from the first message.

I keep these four saved as reusable prompts in AI Toolbox, a browser extension I work on, so they go in with a couple of keystrokes, but they are one line each, a notes file works fine.

Anyone found a version that works inside a long chat, after it has already committed to an answer? I have seen "answer as if I asked this in a fresh chat" suggested and have not tested it yet.

The situation: you're in a new chat and the thing you need is in a conversation from three weeks ago. Normal options are to open it, scroll, copy the relevant part, come back and paste, or to just re-explain it from memory and hope.

Type @@ in the composer instead. A list of your conversations appears, you type a few letters of the title, pick one, and its content goes into the message you're writing. Then you carry on typing your actual question.

A few things worth knowing:

Short conversations go in as they are. Long ones get summarized first, so you're not dropping 200 messages into a single prompt and blowing the context window on it.

The picker matches titles, not message text. This is the one case where your chat titles matter, so renaming a chat to something you'd actually search for pays off here.

It works on ChatGPT, Claude, Gemini and Grok, in the same composer, with the same two keystrokes.

The typical use is continuing something. You had a long planning chat, you start a fresh one because the old one got slow, and @@ brings the conclusions with you instead of the whole history.

One limitation, so nobody wastes time on it: a conversation you created minutes ago may not be in the list yet. The picker reads the local cache, which syncs on load and periodically after that, so a very fresh chat can be missing until the next sync. Reloading the page forces it. We know about this one and it's on the list to fix.

What do you pull in most, planning chats or reference ones?

Upload a short file and ChatGPT reads all of it. Upload a long one, a contract, a thesis, a 200 page report, and most of it goes into a search index instead. Every answer is then built from whichever chunks match the words in your question.

Nothing in the interface tells you which of the two happened. The answer reads just as confident either way.

I learned it asking for a summary of a long agreement. The summary was clean and it missed the one clause I actually needed, near the end, because nothing in "summarize this" pointed the search at it. When I asked about that clause by name, it found it immediately.

What works:

1. Ask about sections by name or page, not the whole file. "What does section 9 say about termination" pulls the right chunk. "Summarize this" pulls whatever it happens to rank.
2. For a real summary of a long file, go section by section. "Summarize pages 1 to 20" and so on. More messages, but every part actually gets read.
3. Ask what it didn't see: "Which sections of this file did you not use for that answer?" It's often honest about it.
4. Split long files before uploading when you need the whole thing read. Several shorter files get read far more completely than one long one.

The short version: a short file is read, a long file is searched. Ask questions a search can answer.

Disclosure: I build AI Toolbox, a Chrome extension that adds search, folders and export to ChatGPT. Its search works on your chats, not on uploaded files, so this one is all native behavior.

What's the longest file you've trusted a ChatGPT summary on?

Over in r/GeminiAI today there was a good thread about assistants answering "what's the latest version of X" from memory instead of searching. The fix that got the most agreement was simple: make it search, and make it name the date of its newest source. Once it has to say a date, an answer from last year can't pass as current.

Here it is as one saved prompt with a blank for the question:

{{question}}

Before answering, search for this. Do not answer from memory. Tell me the date of the newest source you found, and link it. If your sources disagree or are older than 6 months, say so instead of picking one.

To save it:

1. Open the floating toolbox and pick Manage Prompts.
2. Add a prompt, name it something short like "fresh", and paste the text above.
3. In any chat, type //fresh and pick it. A small form asks for the question, fills it in, and the whole thing lands in the composer.

It works the same on ChatGPT, Claude, Gemini and Grok, and it's one library, so you save it once.

Two variations from the comments worth saving too:

• Put the version number of the app or software you're asking about in the question. Without it you get instructions for whatever the menu looked like when the model was trained.
• If you already know the thing is new, say so ("the recently released..."). That alone nudges it to search.

What's a prompt you now run on every time-sensitive question?

Ask Gemini "what's the latest version of X" or "what's the current price of Y" and a lot of the time it answers straight from training data, with full confidence and no sources. Phrase the same question as something that obviously needs today's information and it searches.

The answer looks the same either way. The only difference is whether a Sources section shows up under it, and most people never check.

Three lines I now add to anything time-sensitive:

1. Before answering, search for this. Do not answer from memory.
2. Tell me the date of the newest source you found, and link it.
3. If your sources disagree or are older than 6 months, say so instead of picking one.

Line 2 does most of the work. Once it has to name a date, it can't quietly pass off an old answer as current, and you see right away if the "latest" release is from last year.

For comparisons ("which is better right now, A or B") I add one more:

1. List what changed for each option in the last 3 months before comparing them.

Without that line you tend to get a comparison of how both options looked a year ago.

I keep the first three lines as a saved prompt in AI Toolbox (a Chrome extension I build, it adds folders, search and a prompt library to Gemini), so typing // pastes them in before the question. Pasting them by hand works exactly the same.

Which questions has Gemini answered from memory for you when it should have searched?

Line up the last paragraph of every chapter where AI drafted or polished the ending. Odds are most of them are the same move: the action stops, the character sits with it for a moment, and a final sentence tells you what it meant. She realized nothing would be the same. He wondered whether he had made the right choice. The rain kept falling, and somewhere, something had changed. It reads as satisfying one chapter at a time and deadening across a book, because every chapter lands soft, and a reader has no reason to turn the page when each one has already told them how to feel.

The test takes five minutes: Here are the final paragraphs of each chapter, numbered. For each, name the type of ending: reflection, mid-action cut, new information, unanswered question, a line of dialogue, an image, or something else. Quote the last sentence. Then tell me how many are the same type in a row, and where.

If the answer is mostly reflection, the fix is to choose endings on purpose: Here is the end of this chapter. Write three alternative last paragraphs, each a different type: one that cuts off in the middle of action, one that ends on a new piece of information the reader did not have, and one that ends on a line of dialogue. None of them may explain what the moment meant, and none may use the words realized, knew, wondered, or felt in the final paragraph. Keep my voice and change nothing before the last paragraph.

Pick one, or use them to see what your own ending could do, then write it yourself.

Why it happens, as far as I can tell: the model is trained to finish things. A reflective closing line is the most complete-feeling way to end any piece of text, so it keeps reaching for it, the same instinct that makes it end every email with a summary sentence. Fiction often needs the opposite: an ending that leaves something open.

Two caveats. Sometimes a quiet reflective ending is exactly right, usually after a big scene, and the point is to choose it, not to ban it. And the banned-word list is blunt. It stops the obvious version, but the model can reflect without those words, so read the alternatives for whether they explain the moment, not just for the words.

I keep both prompts saved as insertable prompts in a browser extension I work on, AI Toolbox, but a notes file does the job.

What is your go-to chapter ending when you want the next page turned? Mine is the new-information one, it almost never fails.

We get this question more than any other: does it do the same thing everywhere? Mostly yes, but not completely. Here is the honest breakdown.

On all four

Folders and subfolders in the sidebar, plus a toggle that hides chats you have already filed. Search across your whole history, message text included, and cross-platform search that covers all four at once. Export any chat as TXT, Markdown, JSON or PDF, or many at once as a ZIP. Bookmarks on individual replies, with color labels and one panel for all of them. A prompt library you insert with //, and saved prompt chains you run with .. Context Mentions: type @@ to pull an old conversation into a new one. Smart Tags that group your chats by topic automatically. The Context Meter next to the composer, showing how full the conversation's window is for your model and plan. Folders, prompts and bookmarks are one shared library, so something you save on Claude shows up on ChatGPT.

Only on ChatGPT

ChatGPT was the first module, so it has the longest list of extras: download any reply as MP3 audio, a gallery of every image you have generated, a usage tracker, collapsible messages, a word and character counter, a sound when a reply finishes, grouping for custom GPTs, a command palette, and folder export that keeps the full folder structure in the ZIP.

Only on Claude

The Artifact Vault: every artifact Claude has made for you, from every conversation, in one searchable grid, opening back to the chat it came from.

Grok

Works on both grok.com and Grok inside x.com, with the same folders, prompts, chains and bookmarks on each.

Where we step back instead of adding

Claude, Gemini and Grok already let you pin or star chats natively, so on those three we use their pins rather than adding our own. On ChatGPT we add pinning because it has none.

One known issue

Gemini recently redesigned its search page, and our search controls do not appear on the new layout yet. Search itself still works through cross-platform search (Ctrl+Shift+Period from any tab), and the fix for the Gemini page is in progress. We will post here when it ships.

Free and paid work the same way on all four: the free plan includes the meter, basic search and a starter amount of folders, prompts and bookmarks, and the paid plan removes the caps. All Access covers every platform, including any we add later.

Which feature do you use on one assistant and wish you had on another? That list decides what gets ported next.

Try this before trusting any "should I do X or Y" answer. Ask the question, note the recommendation, then open a new chat and ask it again with the two options in reverse order. More often than you would expect, the verdict flips. The model is not weighing the options evenly. The order you typed them in, and any hint of which one you already lean toward, is part of what it is answering.

This is well documented in AI evaluation research, where models judging two answers tend to favor one position, and it shows up in everyday decisions too: which job offer, which apartment, which laptop, which headline.

The prompts I use now.

The swap test, for anything that matters: Ask the same question in two fresh chats with the options in opposite order. If the recommendation stays the same, trust it more. If it flips, the choice is closer than either answer made it sound, and you should decide on the deciding factor yourself.

The neutral framing, when you only have time for one chat: I am choosing between two options, listed in no particular order. Before recommending anything, make the strongest honest case for each one separately, as if it were the only option. Then name the single factor that actually decides between them. Then recommend, and if that factor is weak, say plainly that it is close.

For more than two options: Rank these options with a one-line reason each. Then tell me whether your ranking would change if I had listed them in reverse order, and if so, which positions are really a tie.

When you already have a favorite: Do not tell it. Remove words like "I am leaning toward", "I really like" and "or maybe" from the question. Your lean steers the answer more than the order does.

Why this happens, as far as I can tell: the model builds its answer word by word from what is already in the conversation, so whatever comes first or gets the warmest description becomes the frame the rest of the answer is built around. The "strongest case for each separately" step works because it makes the model build both frames before it has to pick.

Two caveats. Sometimes the first option genuinely is better, and the swap test is how you find out it is not just the order. And a flipped verdict does not mean both answers are wrong, it usually means the decision depends on something you have not told it yet, so the next useful message is the factor you care about most.

I keep the neutral framing saved as an insertable prompt in a browser extension I work on, AI Toolbox, but it is one paragraph, a notes file works.

Has anyone had the swap test flip on a real decision? I want to know what kinds of choices it is most unstable on. My guess is anything where both options are reasonable, which is exactly when people ask.

This cost me a bad piece of feedback before I figured out what was going on.

I asked ChatGPT to review a pitch for a new project. The review kept pushing the tone toward "friendly and casual". The project was for a law firm. It took me a while to work out why. Months earlier I had spent a week in a different chat writing copy for a coffee brand, and ChatGPT had quietly carried "this person likes a friendly, casual tone" into every chat since.

What is happening

ChatGPT memory has two parts, and most people only know about the first.

Saved memories are the facts it explicitly remembers, the "Memory updated" notices you sometimes see. You can open that list and edit it.

The second part reads your past conversations on its own, without saving anything you can see as a fact. It is how ChatGPT knows things you never asked it to remember. It picks up your job, your preferences, your writing style and old project details, then uses them in new chats, including chats where none of it belongs.

Most of the time nothing in the answer itself flags this. Where the newer memory layout has rolled out, there is a Sources icon under each response that shows which saved memories and past chats were used, and it is worth clicking. OpenAI says it may not show every factor, though, so a clean-looking Sources list is not proof the answer is unbiased.

Symptoms that an old chat is steering the answer:

It assumes a tone, audience or format you never mentioned in this chat. It brings up a detail from an unrelated project. Its recommendations keep circling back to something you used to do. Two people ask the same question and get noticeably different advice.

The free fix, two minutes

1. Look at what it has. Go to Settings, then Personalization, then Memory. Depending on which layout your account has, you will see either two separate switches, one for saved memories and one for referencing chat history, or a single memory control with a summary you can edit. Read the list or the summary. You will probably find something that no longer applies.
2. Get a clean read when it matters. For anything where you need an unbiased answer, like a review, a decision or feedback on something new, open a Temporary Chat and pick the non-personalized option when it asks. The personalized option still uses your existing memories and custom instructions, so it is not a clean read. (Thanks to the commenter who caught that, this changed in late August.)
3. Compare, do not just ask. Run the same prompt twice, once in a normal chat and once in a non-personalized Temporary Chat, and compare what actually changed. If the two answers differ in tone, assumptions or recommendations, that difference is what memory added. You can also ask the model what it assumed about you, but treat that as a clue, not an audit, since it cannot reliably list its own influences. (Both corrections here came from commenters, thank you.)

Before you answer, tell me what you know or assume about me from memory or past conversations that might affect this answer. Then answer as if you knew none of it, and point out anywhere your answer would have been different.

It will not always catch every influence, but it surfaces the obvious ones, and the "where would it differ" part is where the useful surprises are.

I keep a comparison prompt saved as a two-keystroke insert in AI Toolbox, a browser extension I built, but the side-by-side test needs nothing installed.

Has memory ever pushed an answer in a direction you only noticed later? I suspect most people who have used ChatGPT for a year have at least one of these and never connected it to memory.

If your history is spread across more than one assistant, this is the feature that saves the most time, and the one most people never switch on. Here is the whole setup.

Turn it on

Cross-platform search is off by default, because it builds a combined index of conversations from different sites and we would rather you choose that. Open Settings, go to Cross-platform search, and flip the switch. One switch covers every platform.

Then make sure each assistant you use is enabled in the extension popup, and open each site once. Each one indexes its own history in the background, and the search fills in as they finish.

Open it

Two ways. Click Search all platforms inside the normal search on any of the four sites. Or press Ctrl+Shift+Period (Cmd+Shift+Period on Mac) from any tab at all, including a tab that has nothing to do with AI. If that shortcut clashes with something you already use, change it at chrome://extensions/shortcuts.

Read the results

Results are grouped by platform, each with its own count, and every result opens the conversation on the right site. The line at the top shows each platform's state: a number means it is indexed, syncing means it is still filling, off means that platform is not enabled yet. If a chat you expect is missing, that line usually tells you why.

Narrow it down

Open Advanced for the useful part:

Must include and Exclude fields, each with an All or Any toggle once you add two terms. Titles only, for when you renamed your chats to something meaningful and do not want every mention of the same word. A date range, which is the fastest way to turn forty hits into four when you remember roughly when you wrote it.

Where your data is

The combined index lives inside the extension's own storage in your browser. Nothing from it is uploaded, and each site can only write its own rows into it.

Plan

Cross-platform search is on the paid plan. Normal search on each individual site stays free.

One honest limit: clicking a result opens the conversation, not the exact message yet. Use the highlighted snippet to find it in the chat. Jumping straight to the message is on the list.

If the coverage line shows something you do not expect, post a screenshot below and we will sort it out here.

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.

How it works

Post one prompt or one chain you actually use, in the form you saved it: the text, the {{blanks}} if it has any, and one line on what it is for. Real ones only, the kind you reach for weekly, not the kind that sounds impressive.

At the end of the month the entry with the most upvotes, plus one we pick ourselves, get added to the built-in Prompt Library in AI Toolbox, credited to your Reddit username inside the extension. Everyone who installs it after that sees your prompt, with your name on it. No other prize, that one is better than a gift card anyway.

Rules

One entry per comment, as many comments as you like. Prompts must be yours or clearly credited, we check. Chains: list the steps in order, mark which ones wait for a reply. Vote for what you would actually use, not what reads best.

To get you started, the three most used prompts in my own library this month, all fair game to beat:

The stranger 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?"

The briefing for a new chat: "Summarize everything we decided in this conversation as a briefing for a new chat that has no memory of it. Include the goal, every decision, the constraints, anything still open, and the exact wording of any final text we agreed on. Mark anything you are unsure about as UNVERIFIED."

The where-question: "Read this once as a reader who owes me nothing. Quote the exact sentence where you stopped caring, and tell me what had gone wrong by then."

The thread stays pinned through September. Entries after the 30th roll into October's.