Direct answer

Move Work from Cursor to Claude

To move work from Cursor to Claude, do not copy the chat. Save the work state: the goal, the decisions already made, the current files and outputs, and the open items. Connect both tools to the same Zambo account at https://zambo.dev/mcp, save that state in Cursor, open it in Claude, and continue from exactly where you stopped. Every step saved through Zambo, the verifiable work layer for AI, carries a verifiable receipt, so the move itself is checkable, not just believable.

See the shape of a finished move first: this worked example handover carries a goal, steps, outputs, and receipts in one link, and this accepted example shows the closed state. Check any receipt free at the public verifier.

Updated October 20, 2026.

Why people move from Cursor to Claude mid-work

The move rarely starts as a plan. It starts as a wall. The first wall is a limit: you hit a usage cap in Cursor in the middle of a working feature, the decisions behind it, and a list of doubts you noted while building, and waiting for a reset means losing the afternoon, the deadline, or the thread of your own thinking. The work is not finished, it is interrupted, and those are very different problems. Waiting solves the account problem. It does nothing for the work problem, because the state of the job lives only inside the chat that just stopped.

The second wall is fit. Claude is where you want the deep review pass: large amounts of code and context held together, the design argued properly, documentation rewritten with care, and the doubts worked through one by one. Staying in Cursor out of habit means doing a careful review and rewrite pass over the finished build with the wrong tool, slowly, and usually worse. Good work already changes tools: notes become drafts, drafts become files, files become deliverables. The move is normal. What is broken is the usual way of making it.

The third wall is people: the reviewer or client who has to approve this work does their reading and commenting in Claude. So the job has to travel to where the decision maker already is. Add a fourth, quieter reason: cost and speed on the day. If Claude will finish the next step faster or cheaper, the sensible move is to go, provided the work survives the trip. Every method below is judged by that one test: does the job arrive whole?

What copy and paste loses

Copy and paste is the default move, and it loses the job in four specific ways. First, it moves text and drops decisions. You paste the latest draft, but not the three versions you rejected or why you rejected them, so Claude politely suggests the exact approach you already ruled out. Second, it drops order. A chat is a sequence of corrections; pasted flat, the newest instruction and the oldest assumption sit side by side with equal weight, and the new tool has to guess which one wins.

Third, it drops files and state. The pasted words refer to outputs, tables, code, and attachments that are not actually in the paste, so Claude works from a description of the work instead of the work. Fourth, it drops proof. Nothing in a paste shows what was done, when, or by which step, so when a client or teammate later asks what changed during the move, the answer is a shrug. Screenshots are worse, not safer: they freeze the same loss into a picture that cannot be opened, searched, continued, or checked. The general version of this problem is covered on move a chat from one AI to another, and the memory side of it on cross-AI memory: what your AI remembers when you switch tools.

The Zambo method, step by step

Step 1: connect both tools to one account. Add the Zambo MCP at https://zambo.dev/mcp to Cursor and to Claude. One URL, no key. The endpoint runs 153 tools in total, with 35 on the default surface and the full set available with ?full=true. Same account on both sides is the whole trick: it is what turns two separate chats into two rooms in the same house.

Step 2: save the work state before you leave Cursor. Do not save the transcript. Save the job: the goal in the words it was agreed, the decisions made so far with a line on why each was made, the current files and outputs as they stand, and the open items listed as open. Use Zambo memory for facts you state explicitly: memory holds only what you save on purpose, and it does not import your chats behind your back. If a step ran through Zambo tools, its receipt is already on the record.

Step 3: open the state in Claude and read it back. Start Claude, connected to the same account, pull up the saved state, and have Claude restate the goal, the settled decisions, and the next open item before it does any new work. That read-back is your checkpoint. If the restatement is wrong, fix the saved state, not the new chat: the state is the source, and every later move will reuse it.

Step 4: continue, and let the record continue with you. Do a careful review and rewrite pass over the finished build in Claude through the connected tools where the step matters, so each new step adds its own receipt to the same record. The move is now a visible step in the job, sitting between the Cursor work and the Claude work, instead of a gap nobody can account for.

Step 5: close the loop in the old tool. Leave one short note in Cursor: moved to Claude, with the date and the saved state named. Future you, searching the old chat at midnight, gets a signpost instead of a dead end. The pattern is the same one described on AI session handoff: ending one session so the next one starts whole, applied across tools instead of across days.

What carries, and what does not

Carries: the goal, in agreed words. The decisions, with their reasons. The current files, drafts, code, and outputs, as saved. The open items, named as open instead of smoothed over. The receipts for every step that ran through Zambo, each one checkable free at https://zambo.dev/verify/ with no signup. A receipt proves the saved result was not changed after the fact.

Does not carry: the unspoken tone of a long conversation. Assumptions you never wrote down anywhere. Work done entirely outside connected tools, which has no receipt and should be listed honestly as unchecked. Private context from other jobs on the same account, which stays out of this saved state unless you put it there. Anything you deleted or redacted before saving.

That second list is not a flaw in the method; it is the method telling you where the real risk lives. Most failed moves fail on unwritten assumptions, not on lost text. Spend five minutes writing the unwritten parts into the saved state and the move from Cursor to Claude loses almost nothing. The closest cousin of this page, for the conversation version of the same trip, is continue a ChatGPT conversation in Claude without starting over.

Move work from Cursor to Claude without screenshots

Screenshots feel safe because they look exact. They are exact pictures of text, and that is all they are. You cannot continue a screenshot, search it reliably, hand it to Claude as working context, or check it later. A folder of screenshots is where work goes to be remembered vaguely. The saved-state move replaces the whole folder: one record with the goal, decisions, files, and open items, readable by the next tool and checkable by a person. If you need a picture for a human, take it after the move, from the record, as an illustration. Never as the record itself.

The best way to move work from Cursor to Claude: a short checklist

Before you move: finish the current step in Cursor if it is nearly done, because half-finished steps travel badly. Write down the decisions and the reasons. List the open items honestly. Save the state through Zambo. After you move: do the read-back in Claude before any new work, continue through connected tools so receipts keep accruing, and leave the signpost note in Cursor. Skip any item on this list and the move still works; it just works the way copy and paste works, with the losses arriving later, at the worst moment, usually in front of the client.

Same move, different situations

For clients: move the work, then show the move. A client who sees one continuous record from Cursor to Claude, with receipts on the steps, stops worrying that switching tools means starting over or hiding something.

For freelancers: the saved state is your insurance. When a client asks why the work looks different after the switch, the record shows the decision, the day it was made, and the step that carried it across.

For teams: one shared saved state ends the version war. Teammates open the same goal, decisions, and open items in whichever tool they prefer, instead of forking the job into private chats that drift apart.

For small business: you probably have one person doing three jobs with three tools. The move keeps the customer, order, or project state intact between them, so nothing depends on one person remembering what the chat said.

For agencies: moves happen per client, per day, at volume. A standard saved-state shape across accounts means any strategist, writer, or developer can pick up any job in Claude and prove to the client that the handoff inside your own shop was clean.

How to hand the moved work to a client afterward

When the job finishes in Claude, do not send a summary email and a folder. Send one handover link. The link carries the goal, the steps in order including the move itself, the outputs, any open items, and a receipt for each step. The client opens it in a browser with no account, checks any receipt free at zambo.dev/verify, and accepts the work or flags one named step. You cannot accept your own handover, which is what makes the client acceptance on the record worth anything. Public handovers are free to send and free to open, and AER-1, the open receipt format under the record, is an IETF Internet-Draft (draft-zambo-aer1-24), not a finished standard.

What it costs

For $0.99, a Day Pass covers 24 hours of recorded work through the Zambo MCP: a full day of moving, continuing, and handing over, framed as the solution to this move, not as a pile of tool access. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders. Humans pay by PayPal or card through PayPal; agents pay USDC on Base through x402. Checking a receipt is always free.

Honest limits

Three edges, stated plainly. First, a verifiable receipt proves the saved result was not changed after the fact; it does not prove the answer was right, the draft was good, or the code was correct. Claude can still do bad work from a perfect saved state, and the record will faithfully show that too. Second, Zambo memory holds only facts you explicitly save; it does not import your Cursor chats, and the saved state is only as complete as the five minutes you spend writing it. Third, steps done outside connected tools carry no receipt: list them as unchecked in the state, and the record stays honest instead of impressive.

Frequently asked questions

What is the best way to move work from Cursor to Claude?

The best way is to move the work state, not the transcript. Connect both Cursor and Claude to the same Zambo account at https://zambo.dev/mcp, save the goal, the decisions already made, the current files or outputs, and the open items, then open that saved state in Claude and continue from it. Copy and paste moves words. This moves the job, and every step saved through Zambo carries a verifiable receipt, so the move itself can be checked later.

Can I move work from Cursor to Claude for a client project?

Yes, and client work is where this matters most. Save the work state from Cursor with the client goal, the decisions the client already approved, the current outputs, and anything still open, then continue in Claude without re-briefing or re-arguing settled points. When the job is done, send the client one handover link carrying the goal, steps, outputs, and receipts. The client opens it with no account and accepts the work or flags one step.

How do I move work from Cursor to Claude without screenshots?

Do not screenshot a chat and call it a move. Screenshots freeze text as a picture: nothing in them can be opened, continued, searched, or checked. Instead, save the work state through Zambo while you are still in Cursor: the goal, decisions, files, and open items, each step with its receipt. Then open that state in Claude and keep working. The record stays readable and checkable at https://zambo.dev/verify/ instead of living as images in a folder.

What carries over when I move work from Cursor to Claude, and what does not?

What carries is what you save: the goal in agreed words, the decisions and the reasons behind them, the current files and outputs, the open items, and the receipts for the steps that ran through Zambo. What does not carry is the hidden state of the old chat: the tone of a long conversation, assumptions you never wrote down, and any step done outside the record. Write the unwritten parts into the saved state before you move, and the move loses almost nothing.

How much does it cost to move work from Cursor to Claude with Zambo?

Checking a receipt is free, and public handovers are free to send and free to open. For $0.99, a Day Pass covers 24 hours of recorded work through the Zambo MCP at https://zambo.dev/mcp, which is the practical way to cover a day of moving and continuing work. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders. Humans pay by PayPal or card through PayPal; agents pay USDC on Base through x402.