The Handover I Needed From Claude Code

I reopened a Claude Code session and I had no idea where I was.

Not in the philosophical sense.

Literally.

I had one repo in one terminal, another repo in another terminal, a third thing half-open somewhere else.

Calls, messages, kids, life, whatever.

Hours later I came back and scrolled.

Read.

Scrolled more.

Was it finished?

Was it waiting for me?

Did it actually change something or only investigate?

Every time I lost minutes reconstructing the state of my own work.

Across several repositories, many times a day, this becomes stupid very fast.

When you work on several repositories at the same time, the expensive part is not only doing the work; it is re-entering the context you already paid for.

A few days ago I wrote about twenty terminals and no idea which one needed me. That solved a different problem: which session is waiting.

This one solves the next problem.

Where am I inside the session I just opened?

The block I wanted to see

On 7 September 2026, in about twenty minutes, I made every useful Claude Code turn end in the same way. On its own. Without me asking.

If the turn changed something, it has to leave me a handover.

Same place.

Same shape.

Every time.

The goal was not to make the output prettier; the goal was to stop paying the context-switching tax every time I came back.

The shape is this:

What I did

• one complete sentence per bullet

What’s left to you

• one complete sentence per bullet

That’s it.

Two lists. No table. No nesting. Flat bullets. Around seven bullets per list, ten total as a soft ceiling.

If it becomes long, it already failed.

And the second list is never skipped.

Even when there is nothing left for me, it still tells me what to check to confirm.

It is a hook, not another thing to remember

I did not build a command I have to remember. I did not add another sentence to type at the end of every prompt.

I will forget.

So it is a hook: a small script Claude Code runs automatically on specific events, wired once in my settings and then forgotten.

It is registered on two Claude Code events.

When I submit a prompt, it resets state for the new turn.

After each tool call, it decides whether this turn deserves a handover.

This detail matters.

It fires during the turn, not at the end of the turn. Deliberately.

I never attach it to the event that ends a turn, because I do not want extra turns or tiny loops inside my terminal.

The hook only injects a reminder into the running turn.

Extra context for the model, invisible to me.

It does not block anything. It does not reject anything. Worst case, it does nothing and disappears.

It does not ask: “Was this important?” It watches what happened.

Did Claude write or edit files? Then the reminder fires.

Did it run a command that changes state? A commit, a push, a migration, a deploy, an install, a delete. Then it fires.

No file edits, no state-changing command, but more than ten tool calls in the same turn? It fires too.

Because sometimes a turn does not modify code, but it still burns real context.

The decision is based on what the session did, not on what I hoped the session was doing.

When in doubt, it stays quiet.

It fires at most once per turn.

And if anything inside the hook goes wrong, it silently does nothing and gets out of the way.

No drama.

No broken session.

Rule 6 was half wrong

In July I published the skill that stops Claude forgetting tasks. It had rule 6, and the spirit was good: no file paths, no function names, describe behaviour, not code.

I ran that for two months before noticing the problem.

The first version of this handover inherited the same instinct.

No paths.

No jargon.

No internal details.

And it quietly killed the coordinates together with the noise.

I would come back hours later, from another repo, another terminal, another mental universe, and the recap would tell me what happened.

But not where.

The where is always needed; the how-it-works-inside almost never is.

So I split the rule.

Function names, variable names, internal code explanations, random line-by-line commentary: still banned.

But the repo, the exact command, the exact address, the file to open manually: always there now.

Rule 6 was half wrong.

Clean rules are nice.

Useful rules are better.

I also built a kill switch the same day.

One empty file turns the whole thing off instantly. Everywhere, or only inside one project.

I do not want an argument with my tools.

I want to create one empty file and move on.

Small automation.

Big sigh of relief.