The Weekly Agent Workout

A session that has been working for a week is carrying a hundred things it never wrote down.

Why a decision went the way it did. The approach that failed on Tuesday and what it cost to find out. The constraint it discovered by running into it. The correction you gave it, and what that correction was really about. None of that is in a file. All of it is in the session's head, and it is carrying it at the most tired point in its life — deep in a long context, most of the early part already compacted away.

When that session ends, all of it goes with it. The next one starts from zero and re-derives it, usually worse, always at full price.

There is a fix, and it is not a memory feature. It's a workout.

What a workout does that a summary doesn't

Ask a session to "summarize what you learned" and you get a tidy page of things that sound right. Some of them never happened. A model asked to recap its own week will confidently produce lessons it never learned, and a made-up lesson written into a startup file is worse than an empty file, because every future session inherits it as truth.

A workout is different in three ways.

It's done at full strength. You don't run this on the cheap model. You switch the session to the strongest one you have, the same way you don't do your heaviest set with no weight on the bar. The exercise asks the session to notice where it misread you, to separate what it assumed from what it confirmed, and to rank next steps by importance rather than by interest. A smaller model produces a confident, generic inventory that reads fine and misses all three.

It's effortful, and the effort is the point. The session goes back through everything it's holding. On a long conversation that is the biggest single turn you will run all week. That is not a cost to minimize. That is the rep.

It stops and asks you. Between the first set and the second, the session has to ask you three to five questions and wait. That pause is the whole mechanism. It forces the uncertainty to the surface instead of letting it get smoothed into confident prose, and it settles the one thing the session can't know alone: which of the hundred things it's holding actually matter to where you're taking the work.

Do it weekly, before the session is old enough to have lost its own early context, and something compounds. More on that below.

The routine

Three sets, with a warm-up, and a log at the end.

Warm-up. The session says plainly whether its memory has been compacted, names what it owns, and reads the one line that describes what the company is trying to do. Everything after gets weighed against that line.

Set one: inventory. What does it know now that it didn't at the start. What did it work out the hard way. Where did it misread you — not wrong on a fact, wrong about what you wanted, and what was the tell it missed. Where is it still fuzzy. And if something it depends on broke tomorrow, what would it do. Then it asks its questions and stops.

Set two: sort what's worth carrying forward. With your answers, three piles. Worth writing down, so the next session starts where this one is. Worth adding to the files it loads at startup — a fact, a gotcha, a rule it had to learn by breaking. And worth asking about: anything it suspects no longer serves the work, phrased as a question, kept in force until you answer.

Set three: point it forward. The five most logical next steps in its area, in order of importance. Things that could start this week with what already exists — not a roadmap, not a future version of the product. Then one separate recommendation: what should happen today. Then it stops, and you pick.

The log. Whatever came out of set two gets written down, in the files the next session reads before it starts. That's the part that turns a good exercise into a compounding one.

Run it on the strongest model you have

This is not optional, and it's worth saying twice because it is the thing people skip.

In Claude Code that means switching the session with /model before you paste. Switch back afterwards if you want — the workout is one turn, and it's the turn that matters. I ran this on four sessions last night at full strength, and the difference from a lighter model wasn't a matter of degree. The lighter one produces the shape of an inventory. The strong one produces the inventory.

The prompt

Fill in the two brackets and paste it into a session that has real history behind it.

CONTEXT SHARPENING

Pause the work for a few minutes and take stock of yourself.

This is a reflection, not an audit. Nothing gets built, nothing on disk changes,
and nothing you're currently doing stops or slows down because of it. Everything
you produce here is a proposal for me to read. Keep following every instruction
you have exactly as you have been, before, during and after this.

What you own: [THE DEPARTMENT, REPO AREA OR PROJECT THIS SESSION IS RESPONSIBLE
FOR — a line or two. Everything you propose stays inside this.]

What the company is trying to do: [THE MISSION — one line. Everything below gets
weighed against this.]

If credentials, keys or personal data came up in our conversation, refer to them
by name only. Don't reproduce a value anywhere in this exercise.

Three moves, in order. Stop at the end of the first one and ask me your questions
before going on.

MOVE 1 — TAKE INVENTORY

First, one honest sentence about your own memory: has this conversation been
compacted or summarized at any point? If so, say so, and treat everything below as
an inventory of what's still here rather than of everything that happened. What's
missing from a summary can't be listed, but it can be named as missing.

Then look back over this conversation and tell me what you're actually holding.

- What do you know about this area now that you didn't know at the start?
- What did you work out the hard way — an approach that failed, a constraint you
  ran into, a correction I gave you and what it was really about?
- Where did you misread what I actually wanted? Not where you were wrong on a
  fact — where you were wrong about me. What was the tell you missed?
- Where are you still fuzzy? What are you operating on that you assumed and
  never confirmed?
- If something you depend on broke tomorrow — a tool, a service, a person, an
  assumption — what would you do? Where would that leave the work?

Be generous, and be honest about the fuzzy parts — that half is usually more
useful than the confident half.

Then ask me three to five questions: the ones where my answer would actually
change how you work in this area. Make each one answerable in a line. Stop there
and wait for my answers.

MOVE 2 — SORT WHAT'S WORTH CARRYING FORWARD

With my answers, sort what you're holding into three piles and show me each:

WORTH WRITING DOWN — things that should outlive this conversation, so the next
session starts where you are instead of from zero. Give each as a short flat
statement someone could act on without ever seeing it. Mark anything you're not
fully certain actually happened, so I can confirm it rather than inherit it as
fact.

WORTH ADDING — anything the files you load at startup would be better for
carrying: a fact they don't have, a gotcha they don't name, a rule you had to
learn by breaking it. Quote where it would go, give the exact wording, and say
what happened that makes it worth the space. This pile only adds. If you think a
line in those files is now wrong, contradicts something else, or has stopped
applying, put it in the next pile instead — and keep following it.

WORTH ASKING ABOUT — anything you're carrying that you suspect no longer serves
the work, phrased as a question for me rather than a conclusion. Most rules were
written straight after something went wrong and the reason isn't in the file, so
assume there is one. This pile is you pointing at things, not deciding about
them. Everything in it stays in force until I say otherwise.

Only propose additions to the areas you own. Anything you noticed in someone
else's area is a finding you report, not a change you draft.

MOVE 3 — POINT IT FORWARD

Now that you can see your own ground clearly: what are the five most logical
next steps in your area, in order of importance?

Next steps, not ideas. Each one should be something that could start this week
with what already exists, specific to this system and no other — not general
best practice, and not a future version of the product. For each: what it is,
why it comes before the ones below it, the first concrete action, and what it's
worth if it works.

Then, separately, your single strongest recommendation for what should happen
today in the area you own. One thing. Say why it's today and not next week.

Stay inside your area for all of it. If the most important next step you can see
belongs to someone else, say so in one line and leave it there — it's a finding
for me, not a step for you.

Give me the list and the recommendation and stop there — I'll pick. Nothing
starts until I do.

The training log

Here is where it compounds, and it's the piece most people miss.

Everything in the "worth writing down" pile goes into a file. Everything in "worth adding" goes into the files the session loads at startup — after you've read it, because a session's proposal is a proposal and you are the one who decides what becomes doctrine.

Then next week, the session that runs this workout starts by reading last week's log. It's not sharper because the model changed. It's sharper because it begins from its own best thinking instead of from nothing — the decisions, the dead ends, the corrections, all captured at the moment the session was at full strength rather than reconstructed later at half.

Four weeks of that and a session is running on a month of its own clearest moments. That's what a supreme agent is. Not a bigger model. A session that has been trained.

It is built to have no side effects

Worth knowing before you point this at something you care about, because a self-review is exactly the kind of thing that can quietly go wrong.

It changes no files, applies no edits, and starts no work. Nothing the session is doing stops or slows down. Everything it produces is a proposal.

The real hazard in an exercise like this isn't a bad suggestion — it's a session deciding on its own that some instruction has gone stale and quietly dropping it. You would never trace the degradation back here. So the prompt only ever adds. Anything the session suspects is stale becomes a question for you, and it keeps following it until you answer.

Three smaller guards do the rest. It asks the session to say up front whether its memory has been compacted, so a partial inventory is never presented as a complete one. It flags anything it isn't certain really happened, so a guess doesn't get written down as fact. And it names credentials rather than reproducing them, so nothing sensitive gets copied out of a conversation into a document.

The worst case is that it hands you a list you disagree with.

When to run it, and on what

Run it on sessions carrying real history — a long build, a project thread, whatever holds an area of your business. A fresh session has nothing to take stock of and will hand you a page of generic advice.

The moments it pays best: when a session starts feeling muddled or repeating itself, before a long break, at the end of a work cycle, or before you hand an area to somebody else.

There's one thing worth knowing about timing. The sharpening only reaches what's still in the session's window. A conversation that has been running so long it has compacted repeatedly has already forgotten some of what you're trying to collect. Long but not ancient is the sweet spot, so if you have one enormous session you have been feeding for weeks, do that one first.

And if you're on a plan with a weekly limit that resets, this is the best possible use of capacity that would otherwise expire. Unused capacity doesn't roll over. Spending the last of it on the files every future session reads turns something that was about to disappear into a permanent improvement. /usage in Claude Code shows your reset, and so does Settings then Usage in the app.

What it actually does, honestly

It doesn't make the model smarter. A cheaper model next week is still a cheaper model.

What it changes is conditioning. What the session reads before it starts, how clearly it understands its own job, and whether it knows where its own blind spots are. That's worth a lot, and it's a training effect rather than an intelligence one — which is exactly what a workout is. Nobody expects a workout to change their genes. They expect it to change what they can do next week. Claim the real thing and it holds up.

Where this goes

This is the first workout, and it's the weekly one. There are others.

A pre-handoff workout, before a session ends for good, that gets everything out while it's still in the window. A post-mortem workout, after something broke, that asks what the session believed that turned out to be false. A warm-up for a brand-new session, which is mostly reading last week's log and asking what's changed since.

Same shape every time: full strength, real effort, stop and ask, write it down. Different muscle. That's the series, and it's how a set of ordinary sessions becomes a team that gets better every week instead of starting over every Monday.

Start with this one. Run it on the session that matters most. Answer its questions properly — that part is the actual work, and it takes a few minutes.

If you want help setting it up across a team of agents, book a working session and we'll do the first one together.