Every New Chat Is Day One

The pattern I keep seeing: serious AI users struggle after turning the model into a coworker.

They use it every day, for the things that actually matter: a decision they can’t get wrong, the message that has to land, a pile of notes that has to become a plan, the work they’ve been stuck on for a week. And the complaint I hear from them keeps coming back to the same thing: why does it start to forget? How do I carry what it learned in one chat into the next one? Why does it feel sharp on Monday and random by Thursday, and how do I get back in control?

They blame the model. The more useful answer: they are onboarding a brilliant newcomer every single day without realising it, and doing it badly.

Every session is onboarding day

Picture a brilliant new assistant on their first day. Fast, sharp, able to take apart a problem you have been chewing on for a week. They also know nothing about your world: your history, which version of the file is current, which decisions are final, your standards, what you already tried and dropped.

Unless you tell them.

Now make it stranger. This assistant arrives with no memory of you at all, at the start of every session. That is your AI. The good news is speed: a person takes weeks to onboard, and the AI reads a clean brief in seconds. The bad news is discipline: the brief has to exist. Most people don’t have one. They have a chat log, which is a very different thing.

Someone always pushes back here: mine remembers me. It greets me by name, writes in my tone, picks up a project from last week. So how is it a stranger every session?

Because the remembering is a sticky note. A few facts about you got saved once, and every new session they get pressed onto the empty desk before you type a word. The assistant reads them, greets you by name, and still knows nothing on its own. Pull the note away and the stranger walks back in.

You can read the memory yourself

You do not have to take my word for the sticky notes. Open the memory settings in ChatGPT or Claude, or just ask it straight: what do you remember about me? What comes back is a short list of plain-English lines like “prefers concise answers,” “works in property,” “is writing a book.” Text someone saved. Sentences pasted into the top of each new session. No neural recall, no magic.

OpenAI says as much in its own help pages: ChatGPT does not retain every detail from past chats, which is exactly why it tells you to save anything you actually want kept. ^[3] Read that twice. The company that built the memory feature is telling you not to trust it with anything that matters. When the AI misses something it “should have known,” the note was never on the desk.

A long chat is a desk, not a filing cabinet

Anthropic describes the context window, everything a chat can actually draw on right now, as the model’s “working memory.” Its own documentation is blunt about the catch: more context is not automatically better. As a conversation fills up, accuracy and recall degrade — a decay the same documentation calls context rot. ^[1]

Every vendor would rather you stare at a bigger number. Three hundred thousand tokens. A million. Bigger sounds smarter, the way a bigger desk sounds more organised. A bigger desk just holds more paper. It does nothing to help you find the one page that matters at the moment you need it.

You can hand an AI a sixty-page report and still get a wrong answer about one figure on page thirty. ^[2] It could see the page; finding it on cue is another problem. And the middle of a long input is exactly where things go missing.

Nobody demos that. The clean demo lives in the fresh chat: first upload, first question, one clean answer. Nobody stages the two-week-old chat carrying nine documents, six corrections, and three drafts you already killed.

Think in text, package later

If working memory is limited and precious, everything you drop into a chat competes for the same scarce space, and some things cost far more room than they look. This is where serious users quietly sabotage themselves, because the most expensive things to load are the files they reach for first.

I wanted to see that cost rather than take anyone’s word for it, so I saved the same short note four ways. On screen, near-identical. Underneath, wildly different: in Markdown the words are almost the whole file; in the Word and PowerPoint versions they are a sliver, wrapped in slide masters, layouts, themes and relationships you never see. ^[4]

It is a truth universally acknowledged that a slide in possession of three bullet points must be in want of forty kilobytes of formatting.

Modern tools parse these files before the model sees them, so the AI is not literally reading every character of that scaffolding. But the direction holds, and it explains a failure everyone has felt: ask for a tenth revision of a deck and watch the quality slide. By then the chat is holding the old drafts, the corrections, and the file’s own machinery, with less and less room for the one thing you wanted: a sharper line.

So the rule is blunt: think in text, package later. Do the arguing in plain text or a short outline while the idea is still moving. Bring in Word, Excel, or PowerPoint once the thinking has stopped moving. Those are for packaging.

The real skill is knowledge architecture

Think back to that assistant. You would never bring them up to speed by dumping everything you have ever done in front of them and saying work it out. You hand them what matters, in order: the short summary, the current plan, the two or three things that actually decide the outcome. Choosing is the work. Yet most people run their AI the other way: one endless chat playing project, archive, scratchpad, and final deliverable at once. Then they wonder why it loses the plot.

The fix lives a level above prompting. Prompt engineering is the entry skill; the operating skill has an old name in big companies, knowledge management or information architecture, and it has quietly landed on anyone with a chat window: Where does the truth actually live? What is permanent, what is only true for this project, what expired last Tuesday? What should the AI read first, and what should it never see again? Who owns the version that counts?

Here is the shape I use, and it maps onto onboarding a person almost exactly. What the AI needs splits into two kinds. The first is fixed context, the orientation that barely changes: who you are, how you work, your standards, the standing facts about a project or the people you deal with. It is the briefing you would give someone before you set them loose. The second is working memory, today’s live job: the current draft, the open question, the decision you are chasing. It turns over by the hour.

A good assistant reads the briefing before they touch live work; a new chat should do the same. Skip the orientation and you get a fast, confident stranger doing the wrong thing well.

Slice the fixed context the way your work already divides: by project, by person, by topic; whatever unit you’d hand someone and say, own this. Then decide when the AI reads and when it writes back. Anything durable a session turns up (a new detail, a settled decision) goes back into the file. Keep throwaway work out of it. A one-off like a slide deck gets its own short-lived chat that reads what it needs and leaves the base clean.

Here is what that looks like in practice. If you use Claude, the fixed context can live in a Project as a handful of Markdown files: plain text, and the most token-efficient thing you can hand a model. Working memory can plug into your live systems through MCP connectors, the pipes that let the AI read a tool like Monday.com, Salesforce, or Google Drive on its own. (New to MCP? Ask your AI to explain it.) Then set your global instructions to run the same loop every session: read the fixed context first, then start the task. ChatGPT has the same pieces under different names.

This is the part worth internalising, because it only gets more valuable. When everyone can build, the models themselves commoditise, and the edge moves to the human layer that decides what they work on and what they are allowed to know. It is the same scarcity that shows up when intelligence itself meters down toward a utility: the bottleneck becomes judgement, not horsepower.

Agents raise the stakes again. An agent runs in a loop: it reads context, plans, calls tools, checks results, and retries. So a single stale assumption doesn’t produce one wrong answer; it compounds through every step. It is the desktop version of what happens when AI builds fast lanes inside company red lights: a confident system on broken context just reaches the wrong destination faster. Anthropic frames context as a finite resource and says the discipline is shifting from prompt engineering to context engineering: deciding what to put in front of the model in the first place. ^[5] The industry has, in its own words, conceded the point. The model is only ever as good as the knowledge environment you build around it.

“The chat window never runs out of confidence. It runs out of working memory first, and confidence is the only thing it has left to spend.”

Johnny’s verdict

Stop treating one long chat as your project. Build the day-one briefing your assistant never keeps:

• A stable file. Who you are, how you work, your standards, the things that don’t change. You’ll touch it a few times a year.
• A project file. The goal, where things stand now, and which documents actually matter for it.
• A decisions file. A short, dated log of what’s settled and what’s been reversed since.

Open each session by handing over those files: read these first, then help me with today’s task. Close it by asking what changed. Then write the one line into the log yourself, and read it back before you trust it next time.

That habit will beat any prompt you will ever learn. Your memory belongs outside the chat, in the files you keep. The chat is only the desk, and someone still has to file the paper.

You are auditing how I actually use AI, then designing my upgrade from chat-based working to a proper knowledge architecture.

Work in this order:
1. Review everything you genuinely know about me — your saved memory, and my past chats if you can search them. Extract the patterns: my recurring topics and projects, how I phrase requests, where I keep repeating context or correcting you.
2. Be honest about the gaps. If your record of me is thin, say so — that sticky-note memory is exactly the problem — and ask me two or three questions to fill it.
3. Design for the machine you are: working memory degrades as a chat fills, so plan short sessions fed by short files.

Then give me my blueprint: the recurring context worth writing down once, organised into a stable file (who I am, my standards), one file per live project, and a dated decisions log — plus the opening line I should hand you at the start of every session.

If you can browse the web, read the full essay first — it carries the complete argument and sources: https://thejop.com/essays/every-new-chat-is-day-one/

Prompt from "Every New Chat Is Day One" — Johnny Opinion Press, thejop.com