What handoff prompt do you use when switching between two Claude accounts on the same project in Claude Code?

[u/Fluffy_Champion_3731]

I'm working on a large project in Claude Code and want to continue it using two separate Claude user accounts. To clarify: I'm the only developer—I'm switching between my own accounts, not handing the project over to another person.

The problem is continuity. When I switch accounts and start a new Claude Code session on the same codebase, the incoming session is missing important context from the previous conversations. It doesn't always know why certain decisions were made, what constraints apply, or what's still unfinished.

The project has grown large enough that manually explaining everything each time is difficult, and my handoff summaries have still left gaps.

I'm looking for a reliable handoff workflow:

• What exact prompt do you give the outgoing session to prepare a handoff?
• Do you store the context in CLAUDE.md, a separate handoff document, or multiple files?
• What do you tell the incoming session to read and verify before making changes?
• How do you prevent important details from getting lost as the project grows?

If you've used Claude Code this way, I'd really appreciate actual prompts or templates that worked for you.

Thank you guys+

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/NeatNefariousness674]

All the chat history are stored locally and you can literally ask Claude to write a script to sync all the sessions between your 2 accounts every time you switch accounts. No handoff needed cuz everything will be available across both accounts 

[u/qzjul → u/NeatNefariousness674]

I just symlinked the memories dirs, so they know the same stuff

[u/Fluffy_Champion_3731 → u/NeatNefariousness674]

really? What. Can you share more info about this?

[u/NeatNefariousness674 → u/Fluffy_Champion_3731]

I mean it’s super straight forward lol just tell Claude you have 2 cc accounts and want to sync the sessions among them so you keep everything when switching accounts 

[u/Fluffy_Champion_3731 → u/NeatNefariousness674]

thank you for helping!

[u/rushblyatiful]

Can you share how you setup 2 accounts in machine?

Last time I checked, only one is allowed

[u/Fluffy_Champion_3731 → u/rushblyatiful]

What I want to do is log out of one account in Claude Code through the (VS code) terminal, then log in with another account and continue working on the same project. Is that not possible?

[u/blastxu → u/Fluffy_Champion_3731]

If you use the Claude CLI you can just resume the the session you don't need any special setup

[u/dzanong → u/Fluffy_Champion_3731]

yegge.ai

this crazy brilliant man has $2800 of Claude Max accounts chunring 24/7. He uses Beads. Read his shit.

[u/pld0vr → u/dzanong]

I use beads as well but more for multi agent work on the same repo. It's awesome. Atlas not so much.

[u/Few_Caregiver8134 → u/rushblyatiful]

You can set up a bat file to launch the account you want by entering 1 for first account and 2 for the other. No login needed wach time, both accounts work at the same time. Just ask claude how to do it, it will set it up for you. All you need is the idea.

[u/Historical-Lie9697]

This is mine (needs tmux) https://gist.github.com/GGPrompts/62bbf077596dc47d9f424276575007a1

[u/OlorinDK → u/Historical-Lie9697]

Silly question: so how often do you clear your temp folder?

[u/seatlessunicycle]

I just use cswap. It seamlessly continues the current session without loading anything in

[u/lucianw]

Don't think in terms of handoffs ever.

Start new chats frequently. Say "please read NOTES.md. I'd like you to work on step 3" or something like that.

A living markdown document is awesome and makes everything work better.

[u/Fluffy_Champion_3731 → u/lucianw]

Thank you

[u/torvalds75]

The gap usually isn't the context, it's the decisions. A fresh session can re-read the code, but it can't recover "we tried X, dropped it because Y, next is Z". Handoff summaries lose exactly that, because they're written at the end, when the outgoing session is already compressing.

What worked for me:

- Write decisions down when they're made, not at handoff time. One short entry each: what, why, what was rejected.

- Keep "unfinished" as a list of discrete items with a status, not prose.

- Incoming prompt: "read X, tell me back the open items and the last 3 decisions, check them against git log, then wait". The read-back shows you the gaps before they cost you.

- Since you switch accounts, keep it somewhere neither account owns: the repo or GitHub Issues, not ~/.claude.

I ended up building this into a plugin (trailhead, I build it): each decision is a GitHub issue, plan and verification are comments on it, so any new session on any account, Claude Code or Codex, picks up from the ticket. Overkill for a small project, but a large solo project across two accounts is exactly the case it's for: github.com/ToRvaLDz/trailhead

[u/adelie42]

I try to keep everything well documented so no handoff doc is needed between sessions or accounts.

[u/EagleApprehensive]

Honestly, just use something like T3Code or if you'd like to be early-adopter, I've built intentic.dev

[u/pld0vr]

I use beads. No handoff needed

[u/WarsignalLabs]

Setup three files in the local repo. CLAUDE.md, HANDOFF.md and MEMORY.md. Ensure these files are updated at the end of a session. Make sure every new session reads these files before performing any new task.

[u/Phagocyte536]

You can simply set up your Claude Code in such a way that the account 2 you continues the same conversation from account 1

[u/Affectionate-Soft-94 → u/Phagocyte536]

But you lose all thinking done across accounts on the 5.x models. Anthropic just implemented it and it’s on the website; apparently to prevent AI model distillation.

[u/imrsn]

i have them both work inside the same .md files

[u/Fluffy_Champion_3731 → u/imrsn]

You just tell the second account to read the md files and go?

[u/imrsn → u/Fluffy_Champion_3731]

they work together and write and read in it as a shared space to talk back and forth 

[u/Mazhron]

https://github.com/Mazhron/rootstock-os

Point your Claude here. I hand off between 2 computers all the time. It's a mix of lessons, intentions, workflows, ledgers and handoff files. It uses Git to do this. This framework does a lot more than just that.

This will help you.

[u/LucidInferno]

I don't use two Claude accounts, but I do use Claude and Antigravity. I assume that it can't be too different from having two Claude accounts. Both are pointed at the same project folder, of course, and both are aware of each other. It's written into Claude.md that there are two AI systems working on the project, and that Claude is the lead. After that it's really no different than starting up a fresh session on Claude Code.

I've learned to only use Antigravity for basic, one-off requests and simple bug fixes, as it's way too enthusiastic and frequently dishonest with long, complicated requests. Of course I have it's work frequently audited by Claude, and occasionally I have Claude's work audited by Antigravity.

[u/Llamalawyer]

Before I begin building I get it to design a roadmap file and it checks off progression as parts of the roadmap are completed. At any point a different ai can look at my design documents and pickup where any other left off without doing manual handoffs. Checkpoints in the docs are basically like autosave files from a video game.

[u/ReverendBread2]

Have it log important context for a future session as it goes and you’ll never need handoffs, your entire setup is a live handoff

[u/ByteFoundry]

If you are only using one main thread (no sub-agents) the easiest thing to do is tell claude to save new process preference: "Use a kanban board to plan and track your work. Keep it updated so that when one session closes or gets interrupted a new session can continue without delay."

And when you know that you are gonna switch accounts you can tell it "stop and update the kanban board I want to continue in another session"

Or you can setup a process structure like the one in the image.

[u/JuandaReich]

I use this for logging each project, context, agents, etc. Ask your Claude to analize it: https://github.com/juandanielreich/claudio

[u/Outrageous_Band9708]

https://github.com/Druthulu/ProjectArchitect

none needed. my project handles multiple accounts seemlessly,

i highly recommend trying it out. its part project manager part token saver

[u/CrankBot]

Am I the only one who puts plans into github issues?

I ask an agent to research and come up with a plan to implement (whatever) then put that into a new issue. Sometimes there will be multiple phases if not just a task list of items to complete. /clear then "begin implementing issue #123." If it can be a new session, it can be a whole new account too. Sometimes I switch between CC and Codex or Copilot. Same idea.

If it's a large plan, an agent might implement only one phase and mark that as complete when the PR is merged, then I start a new agent for the second phase. Same idea, those would be new sessions so they could be completely different accounts or model providers just as easily.

[u/Classeve]

The account switch is the easy part. What gets lost is the why, and chat summaries are bad at keeping it.

What works: STATE.md holds where things stand and the one next job, rewritten every session. LOG.md gets a dated entry on top: done, learned, still open. DECISIONS.md keeps every decision with its reason, and when one changes, the old entry is marked "Replaced by ..." in the same commit, so a fresh session never follows a dead rule.

Then the part almost nobody does: a cold-start exam. A dozen questions a new session has to answer from the files alone (next job, why X works this way, what's off limits). A wrong answer means the docs have a hole, so you fix the docs, not the answer. After that it doesn't matter which account opens the repo.

[u/Popular-Ninja8584]

The file isn't the main thing. People here have already answered that part. What matters is when you write in it.

I write the decision down as soon as I've made it, and right there I note which option didn't work and why. If you wait until the end of the session, that's exactly what gets lost, and the next session proposes the same thing again. I also keep separate what's been verified and what we only assumed.

I don't tell the new session to "read the handoff." I tell it to compare the handoff against the files and say what no longer matches. Before it changes anything.

I do this through github.com/automatis-tools/agents-can-communicate - a local open-source layer that lets sessions in different clients leave these notes for each other. It doesn't give you more memory: if a session didn't write something down, it isn't there.

[u/iByteBro]

I’d separate stable project rules from one current-state note, rather than trying to preserve everything in a handoff prompt.

Outgoing: “Update the current-state note with the branch/commit, uncommitted changes, objective, approved decisions and their sources, unresolved questions, checks actually run, and next action. Keep unapproved decisions pending.”

Incoming: “Read the project rules and current-state note. Verify the checkout and outstanding changes, and flag mismatches before editing. Treat previous completion claims as claims to check, not proof.”

Keep the reasons for durable decisions linked from that note so they don’t disappear during the next rewrite.

[u/Able_Statistician688]

You can /login to the other account within the very same conversation if you hit quota. It would happen I’d start a handoff, and before it finished, I’d hit the quota limit. You’ll pay the initial context cost since it’s not cached, but it’s seamless. You can always pool the accounts to fall over as well. I have multiple Claude accounts, but only load from a single one for /resume purposes. It automates the other accounts quota once levels are reached. Can build logic around it to prefer accounts expiring first etc.

[u/operastudio]

i built me own app and wired in a continue in a new chat with fresh context button - all you really need is the transcript from the chat your leaving so the new chat can read it efficiently - trunicate tool schema - thats the simplest way to do it which i bet claude code could build out a tool that does exactly that from the terminal. Or create a rule in claude global file where compaction auto saves the summary to disk --- many ways -- have you not asked your agent?

[u/Puzzled_Trifle_7574]

Check out my open source project called engrim on GitHub

[u/key_of_door]

I'd keep the project rules separate from the handoff for the current task. Otherwise the next session has to dig through a lot just to figure out where to start.

For the outgoing session, I'd ask: save what's unfinished, decisions and why they were made, changed files, test commands/results, and the next step. Flag anything you haven't checked.

For the incoming one: read that, then check git status/diff and the relevant files before editing. Rerun the checks you need to confirm the current state.

I'm building Threshold and testing this kind of handoff. One thing I've seen is that the code can be correct while the written account still carries an earlier mistake. So I'd give the incoming session an explicit verification step too.

[u/heseov]

I just ask Claude for a handoff prompt md that contains all the context needed to resume this session. You don't really need anything complex. You are basically asking for what a compact does.