Your conversation doesn't survive the terminal

The idea hits while I’m making coffee. Not a vague notion — a specific one. I pull out my phone, open Claude, start talking. Twenty minutes later I have a working design, three variations explored and discarded, a list of constraints I hadn’t considered, and a rough implementation plan.

Then I sit down at my laptop and open Claude Code.

It knows none of this. The context is sitting in a browser tab on my phone, tied to a chat session that doesn’t cross into the CLI. Every insight from the last twenty minutes is locked behind glass.

The obvious solution that doesn’t work

The first thing I tried was the obvious thing: copy the chat, paste it into Claude Code.

This fails for the same reason dumping a standup transcript into a ticket system fails. A conversation is not a document. It’s full of wrong turns, clarifications, “wait, no, actually” moments, repeated context-setting, and enthusiasm that hasn’t been pressure-tested yet. A raw chat dump is volume without signal.

The agent does its best, but it’s fishing for decisions in a river of words. It misses things. It hallucinates connections. It burns tokens re-reading preamble that should have been cut.

The engineering rabbit hole

The next move was the thing a developer does when they want to avoid a simple problem: I built a system.

The idea: a local Ollama instance would summarize my Claude chats into structured notes. A Python script would feed conversation chunks to an 8B model, Claude Code would validate the summary quality, and anything that failed three times would get flagged for human review.

The infrastructure looked reasonable at the time:

services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - NVIDIA_VISIBLE_DEVICES=all

volumes:
  ollama-data:

It was a fun evening project.

It did not work. The 8B model on a laptop GPU timed out on longer conversations. When it didn’t time out, it added its own interpretations and quietly dropped specific details — exactly the opposite of what a handoff needs. When the summaries made it to disk, Claude Code’s grep-based retrieval ate tokens and still missed things. The system had more moving parts than the problem warranted, and I abandoned it.

What an agent actually needs

The solution is simple: before closing the browser tab, ask Claude to write the handoff document itself.

Something like: “Summarize this conversation as a structured markdown file for a developer picking this up in a new session.” Save the file. Open it in Claude Code with a Read or just drop the path in context.

The structure that works:

Five sections. The agent reads it once and orients immediately. No pipeline, no local model doing lossy compression in the background, no grep hoping to land on the right file.

The key insight is what gets cut. The raw chat had a working design, three discarded variations, and twenty minutes of exploratory thinking. The handoff has the design and the reason the other three were rejected. That’s the whole difference.

The friction that remains

I’d like to tell you this is solved. It isn’t.

As of mid-2025 there’s no native bridge between a Claude web session and Claude Code. You export manually, request the summary manually, save the file manually. The structured format helps — it gives the agent something dense and queryable instead of meandering prose — but the transfer still requires you to stop and do it.

The alternative is to do all your exploration in the CLI from the start. That defeats the point. The AHA moment on a walk, the idea that surfaces while you’re making coffee, the rabbit hole that opens on your phone at 11pm — those happen where they happen. The platform that captures fleeting ideas easily isn’t always the one that builds things, and forcing all thinking through a terminal window kills the spontaneity that made the idea worth pursuing.

For now: structured handoff document. Keep it short, keep it opinionated. The chat model knows what mattered in the conversation — you just have to ask it to tell you before you close the tab.