An hour into a refactor, your coding agent asks whether it should apply the same pattern to the legacy checkout path. The question is reasonable, but answering it means knowing whether the helper was renamed earlier or only discussed, and whether the test you approved was actually written. You were present for every one of those moments, and you can reconstruct almost none of them. So you scroll through forty screens of diffs and tool output, give up after a couple of minutes, and type "yes, go ahead," which is an approval you cannot actually stand behind.
The product displayed every change and logged every step, but it counted on something that never holds up.
The product assumed you could keep the whole session in your head, and nobody can do that.
What the screen owed you in that moment was a running record of the session, kept up to date as the work moved.
Working memory holds a handful of items at a time
Working memory is the mental store for whatever you are working on right now, and it is small. The classic capacity estimate is Miller's seven items, plus or minus two, and the classic workaround is chunking, which means grouping items into a structure you already know so the whole structure takes up one slot. A ten-digit phone number is hopeless as digits and easy as three familiar blocks.
Research on cognitive load, the total demand a task places on that store, splits it into three parts:
- the difficulty of the task itself,
- the extra effort added by how the information is presented,
- and the useful effort that builds the user's understanding.
All three draw on one fixed budget, so every banner and confirmation you make the user track spends capacity the task itself needed.
There is one escape hatch. Experts park knowledge in long-term memory and reach it through small cues, which is why a chess master reads a board at a glance: the board reactivates thousands of stored positions. Working memory is severely limited for new material and effectively vast when a cue connects it to something already learned.
That description should sound familiar, because a language model has the same structure: a limited context window for new input, enormous capability drawn from training. Your team manages the model's window with compaction, retrieval, and caching, then ships an interface built as if the human's window does not exist.
The cost of that gap is measurable. One study found programmers working with an AI code assistant spent about half of each session handling its suggestions, with checking them the single largest activity. A separate randomized trial found that AI assistance made experienced open-source developers 19 percent slower on real tasks while they believed it had made them about 20 percent faster. Holding the session is genuine work, and it appears on no dashboard, including the user's own sense of their speed.
The recommendation: keep the session state on the screen
This is the second recommendation in our essay The Human Factors: do not make people hold the session in their head. The product carries the session state, and the human reads it.
At any moment, the screen should answer three questions without scrolling:
- What has the system been told? The instructions, files, and decisions in play, including anything that has since dropped out of context.
- What has it changed? The working set of files, records, drafts, or settings it has touched.
- What is still pending? The steps agreed on but not yet taken.
The state view also has to be quick to read, not just available, because people check an AI's output only when checking takes less effort than trusting it blindly. If the summary is too much work to read, nobody opens it and you have gained nothing, and this is where the verify-first rule stops being something you ask of the user and becomes your design job.
One of the research papers behind this part analyzed a stock-trading interface and recommended a journal where the trader writes down the conditions of a planned trade in the calm moment of deciding, so that when the price alert fires they read their own reasoning back instead of trying to recall it under pressure. The same move belongs in AI products, and the emotional side of that moment gets its own chapter in Anxiety: lower the stakes at risky moments.
How Granola keeps the meeting on the screen
A live meeting is a session you cannot scroll back, which makes meeting tools a clean test of this recommendation. Granola, an AI notes tool, is designed around the assumption that you will forget most of the call.
It carries the session for you. During the meeting you type only fragmentary notes while it transcribes the audio in the background, and afterward an "Enhance notes" pass fills in detail from the transcript around your bullets. Nothing depends on what you managed to hold.
It keeps your words apart from the machine's. Your typed notes stay primary in black while the AI's additions appear in gray, so one glance separates what you captured from what was added. The product carries the bulk of the session while your structure stays in charge.
Other products make the same move at other moments. Zoom's AI Companion restores state you have already lost: join a meeting late or zone out, and you can privately ask "Catch me up" in a side panel that answers from the live transcript with timestamped citations. ChatGPT Memory handles the "what has it been told" question by showing a visible "Memory updated" chip the moment it stores something, with a settings page listing every saved entry you can delete. And Claude Code's visible task list keeps a multi-step plan on screen as steps that check off as they complete, which does the chunking for you so the whole plan sits in one slot instead of many.
How to build the session ledger into your product
-
Render the plan as a live checklist. Before any multi-step run, show the steps and check them off as they complete, so the user finds the session's position with a glance instead of a scroll.
-
Build a current-state view. Give the user one screen that answers what the system has been told, what it changed, and what is pending, updated as the state changes. If the answer to any of those is "scroll up," you have shipped the problem instead of the fix.
-
Write durable context to disk and reload it every session. Give your product a project memory file the session reopens with, so a small cue stands in for the whole stored structure and the user stops re-explaining. We cover building that file in working with AI.
-
Capture decisions while the user is calm and replay them when they matter. When the user sets a constraint or makes a call, record it, and when the moment that call governs arrives, show it back without being asked. This is the trade journal applied to any product.
-
Cut everything the user must carry that builds nothing. Audit each confirmation, banner, and status line the session asks the user to track, and remove any that do not improve their understanding of what the system is doing.
A 15-minute drill: list what your product makes people remember
Complete a session of about ten turns in your product, or pull up a recent one, then close the window. From memory, write two lists: everything currently in the system's context (instructions, files, decisions) and everything the session changed (files, records, settings, messages sent). Reopen the session and compare your lists against the transcript and the logs.
Every item you missed or got wrong is session state your product asks the human to carry, and you have just demonstrated that the human cannot carry it. Rank the misses by the cost of being wrong about each one, and make the most expensive miss your next design ticket.
Chapter Summary
- Working memory holds only a handful of items at once, while an AI session can generate hundreds. The person cannot keep all of it in their head.
- So the product, not the user, has to carry the state of the session and keep it on the screen.
- At any moment the screen should answer three questions without scrolling: what the system has been told, what it has changed, and what is still pending.
- Show the plan as a live checklist that checks off step by step, so the user finds their place at a glance instead of scrolling.
- Write the lasting context to a file the session reopens with, so the user stops re-explaining the same things every time.
- Record the user's decisions while they are calm, and show each one back at the moment it matters.
- Cut every banner, confirmation, and status line the user has to track that does not help them understand what the system is doing.
- A log or history pane is not a memory aid: it just turns remembering the session into searching it. The test is whether the user can read the current state in one pass.
- The capstone chapter, Run the human factors audit, turns this recommendation into pass-or-fail checks.
- Next we look at what happens to this same limited memory when the stakes spike, in Anxiety: lower the stakes at risky moments.
Sources
- Baddeley, A. D., & Hitch, G. (1974). Working memory. In The Psychology of Learning and Motivation (Vol. 8). Academic Press.
- Miller, G. A. (1956). The magical number seven, plus or minus two. Psychological Review, 63(2).
- Ericsson, K. A., & Kintsch, W. (1995). Long-term working memory. Psychological Review, 102(2).
- Paas, F., Renkl, A., & Sweller, J. (2003). Cognitive load theory and instructional design: Recent developments. Educational Psychologist, 38(1).
- Sweller, J. (2003). Evolution of human cognitive architecture. The Psychology of Learning and Motivation, 43.
- Mozannar, H., Bansal, G., Fourney, A., & Horvitz, E. (2024). Reading between the lines: Modeling user behavior and costs in AI-assisted programming. CHI 2024, ACM.
- Vasconcelos, H., Jörke, M., Grunde-McLaughlin, M., Gerstenberg, T., Bernstein, M. S., & Krishna, R. (2023). Explanations can reduce overreliance on AI systems during decision-making. PACM HCI, 7(CSCW1).
- Becker, J., Rush, N., Barnes, E., & Rein, D. (2025). Measuring the impact of early-2025 AI on experienced open-source developer productivity. METR.
- Graduate research paper on working memory, emotion, and online stock trading (2013), one of the research papers behind this part.
- Product documentation: Granola help center on typed notes and the Enhance notes pass; Zoom support pages on asking AI Companion questions during a meeting; OpenAI Help Center on ChatGPT Memory controls.