Recently I came across the /handoff skill, which I've been using a lot. I find it much better than /compact.
Basically:
- /handoff file creates a short document with the important context from your current session and maybe next steps as checklist.
- You can then start a fresh session with /continue file
- You can also hand the work from Claude to ChatGPT, or the other way around. Very useful at time of session limits.
- Plus your handoff files becomes a useful piece of project memory that you can reference later.
I find this much more useful than /compact or /clear because the context is saved in something portable instead of being tied to one session and i've seen better results doing this every 20 messages or so than running long sessions.
> Plus your handoff files becomes a useful piece of project memory that you can reference later.
I've been doing this since I started agentic development, and have a whole framework based on this; Simply put I define workflow s that output templated files for everytype of tasks that happens in development.
I started doing this and then a colleague of mine recommended me OpenSpec. It might be overkill for small projects but it’s pretty clean and if you have goldfish memory like me, it helps to track changes.
I now feel a bit silly but I reinvented the wheel during my last lil project and indeed found it very powerful. A variant of it is the "implementation (handover) prompt" when I conclude the planning session with plans and design documents, updated handoff, clean tree and a file for a new Opus implementing orchestrator (unusually do a single, highly specific implementer and a single, highly specific tester).
After implementation and task-level tests I end up with a long and very detailed implementation progress ledger and a summary findings from the orchestrator.
Then in the new session I do the whole branch tests.
Works really well, uses much less tokens than any other approach with more of Opus and very little repetitions/corrections.
Yeah, making it a skill is just much more convenient. It can be a very simple skill, a one liner asking the agent to gather the context and write a handoff for another agent. My skill is unnecessarily complex if that's the only requirement.
This is where I landed too. Basic skill for a Jira-like task board and another for keeping an orchestration ledger. Let’s me arbitrarily clear context without losing big picture knowledge.
I've been using my own variant docset driven development since late last year. It emerged organically for me by adapting to the limits of the agents.
- Prefix-numbered sets of documents, keeping them clustered visually and easily referenced by humans and agents. (124.5 = docset 125, phase 5)
- Each doc gets a suffix. Most of the time STRATEGY is the first doc. Sometimes NOTES, DISCUSSION, or HANDOFF though.
- Once the strategy doc is comprehensive, the multi-phase checklist PLAN doc can emerge.
- During execution, the agent drives the PLAN while purposefully expanding lightly scaffolded phases before entry.
- As the user, I drive a PROGRESS doc during the PLAN execution. This tracks the progression of my own questions and the important work summaries that I need for tracking the current work trajectory and for historic analysis over past decision-making.
- Any concern that exceed the scope of the active docset numbers calls for a new one.
- A "docs/archive" folder is kept where I sweep docsets into numbered eras.
I have aliases and templates too, but DDD is so simple that it's overkill.
Any modern reasoning agent can take the plain explanation above and understand you effortlessly when you say "open a new docset strategy" or "read docset 125 and proceed".
Ah I've been doing handoff manually by asking the model to do it. If Claude's handoff includes better context than its summaries, it's probably worth checking out.
I prefer to avoid its internal magic mechanisms. The LLM can read documents like a human (actually better since...no ADD) so I ask it to create documents. This also has the benefit that you can change to a different AI tool and the information is still usable.
I have been doing this a lot even without a skill, having Fable write a planning document, then spawning an Opus subagent with instructions to strictly follow the plan and report any deviance at the end. It also helps that then the plan is always saved in an md file so any future agent can look at it and see what happened.
Interestingly, this was tackled in this blog post[0] a month ago. They claim that plan files aren't token-efficient, because after reading the plan the workhorse model then reads all the relevant files anyways.
That link just says the planning stage should vet the idea concretely so that the plan focuses on a solution that won’t immediately have to pivot.
And I think plan files should focus on general ideas and invariants, not do “implementation as prose”. That way they perform as mini-ADRs that are useful historically, especially to mine why the system is the way it is.
My plan and implementation files are task specific (so specific workhorse reads only its own slice), and the workhorse itself is spawned from an orchestrator with a very specific small prompt.
I managed even the orchestrator to NOT read the plan whole, at once, but in sections.
The most useful thing is the task ledger the task agent leaves behind, which alongside its structured status message makes a very resilient handoff between all stages.
/handoff is the skill I use when I plainly are about to run out of token budget to give to a different harness system. Using this to avoid long sessions is something I will need to try, plus maybe "caveman" mode to cull the verbosity.
It might be even better if the harness were to automatically write a handoff note under some circumstances? If the user is away and the cache is going to expire, that would be a good time to do it.
I've been doing handoffs manually, but maybe the command is a better way. It's a great way to keep track of work, remove useless context, and more importantly, it's an enforced "what is the agent doing" line - you immediately notice if the handoff writing is missing something or confused. Commit each and every one (git is the unsung hero of AI).
Basically:
- /handoff file creates a short document with the important context from your current session and maybe next steps as checklist.
- You can then start a fresh session with /continue file
- You can also hand the work from Claude to ChatGPT, or the other way around. Very useful at time of session limits.
- Plus your handoff files becomes a useful piece of project memory that you can reference later.
I find this much more useful than /compact or /clear because the context is saved in something portable instead of being tied to one session and i've seen better results doing this every 20 messages or so than running long sessions.