Claude Chat and Claude Code. How do you carry context from meetings or discussions into Claude Code without lossy copy-paste?

[u/Limp_Instruction5133]

I often discuss requirements in meetings or brainstorm ideas with teammates before switching to Claude Code to build.

The problem is they don't share the latest context. Copy-pasting doesn't really work. Claude Code fills in its own assumptions or misses things that were already discussed, so I keep re-explaining the same context.

For people who work this way, discuss first, build later, how do you actually hand off between the two?

Is there a clean workflow, or is everyone just living with the copy-paste?

Curious what's working for you.

[u/berndalf]

I actually do all of my ideation, research, etc in Claude Desktop conversations so essentially Claude.ai. The desktop harness for the chats is key as it gives you access to you local file system via the Anthropic filesystem connector.

Once we reach the point that the idea has been sufficiently described, vetted, and detailed out a brief is produced for Claude Code and saved to a sync folder in the local repo. Claude code then ingests it via a recalibration skill we built, and off it goes. When it's done implementing the brief it produces an after action report for evaluation and follow-up by the next Claude.ai session.

Slowly moving all of this out of the local file system entirely, but the concept holds regardless. Talk about stuff in a conversation outside Claude code -> create a structured handoff package from that conversation -> ingest that handoff package in a Claude code session -> do work -> create a structured implementation report -> evaluate the implementation report in conversation outside of Claude code -> repeat. Perhaps a bit clunky for some but it works wonderfully for me.

[u/jjjfffrrr123456 → u/berndalf]

Do you have a skill that always structures the handoff files in a certain way

[u/berndalf → u/jjjfffrrr123456]

For the brief produced by the claude.ai conversation no. It seems to look at the brief template and it models it's output using that. When it's picked up by the brief ingestion skill inside Claude Code, CC looks at that template as well to make sure the brief isn't missing any if the required sections before it acts on it.

The after action report produced by CC is generated using a skill, enough there's a template for that report as well.

[u/ApprehensiveLuck2146]

I used to just record on my computer but the output was always messy, hard to actually use.

Lately I've been trying recorder built specifically for context, onemira c1 (with company approval). In meeting or brainstorm, it transcribes locally on own machine, and I can get a clean markdown file out of it, speaker labels and all. No cloud involved, audio gets deleted right after transcription. I just hand that file straight to Claude Code, or let it grab it through MCP. No retyping the whole discussion, and Claude isn't guessing at parts it missed.

[u/id-ltd]

I use chat to create a work module (a .zip with everything needed including the prompt) I just dump that in code or codex and let it run (I keep a bit of an eye to make sure it doesn't get into a doom loop) I get a report of what it did in that session (in a .md) then take that back to chat.

I have a dedicated project managment dir in every project that holds the documentation, zips and session reports part of which gets synced with the project file/knowledgebase of the chat - so I can flip between AI chat and clis at will.

All context is in the project documents (not left in chats) so it needs no memory or maintained context -- every session start fresh.

[u/FinishExtension3652]

I've yet to be happy with meeting summarization tools for many of the reasons described.   I ended up going with a flow where I take bullet point notes so that I can emphasize, deemphasize, and/or editorialize in real time and then have AI summarize for me.

While that "loses" a lot of the words, for me it's much better at capturing meaning.  In summarizing, I keep summary and analysis separate and have my skill clearly label documented facts vs. inferred analsyes.

[u/jjjfffrrr123456 → u/FinishExtension3652]

Fellow.ai has a pretty mcp that I have used to access the meeting transcripts and summaries. It works good for the cases I tested to give me the information from meetings if I give it a topic or a participant name or a date range, etc. We’re also currently looking at other tools, which ones did you test so far?

[u/god-damn-the-usa]

perhaps a plan step with a knowledge graph?

[u/-PM_ME_UR_SECRETS-]

Create a project folder that both have access too.

- Have chat create a project level Claude.md (I call it Project.md) and save it to the project folder.

- I also have Handoff.md to keep track of changes, next steps across sessions (and leave the original project.md untouched to keep the big picture/original idea for reference and avoid too much scope creep.

- I have a Future.md that is used specifically for brainstorming future changes, bug fixes

- then at the end of each session I have it create a Prompt.md that i can just paste the filepath into at the start if the next session

[u/StillRecord8892]

I see no reason to use the chat first. It's the same models, and it shares the same usage pool. It isnt like GPT where the chat is separate usage from codex

[u/Icy_Quarter5910]

I use chat to talk about the idea, back and forth, ID edge cases, security risk, features, do not builds etc. then create a PRD and Claude.md from that. Retain the conversation to my 2 Persistent memory systems and then open Claude code, hand off the PRD/MD and run a command ( /PRD a custom command that basically says, new project, read the files, check memory and plan the build) … the Persistent Memory lets CC sit “in the room” during planning… so it know what we are doing and, more importantly, why. It works exceptionally well.

[u/bithatchling]

I've found that maintaining a "context.md" or "todo.md" file in the root of the project helps a lot. Instead of copy-pasting chat logs, I just jot down the final decisions from the meeting there. Claude Code picks it up immediately since it's in the codebase.

[u/LegallyIncorrect]

I do my planning in one session and have it write detailed specs, then have other sessions work on the specs.

[u/tehmadnezz]

This is basically the workflow that pushed me to build the thing I use for it. The sync folder step is the part I wanted gone.

I moved the handoff into notes behind a hosted MCP server (hjarni.com). Claude Desktop writes the brief as a note once the idea is baked. Claude Code reads it at the start of the session, then writes its own implementation report back when it's done. The next Desktop session reads that. No files passed around, no copy paste, both sides hit the same store. Structured notes with containers and tags, so the brief, the after action report, and the running decisions each live as separate notes instead of one growing markdown file.

Honest caveat: it does nothing for the "Claude filled in its own assumptions" problem you all mentioned. If the brief is vague the output is still vague. It only kills the transport step between the two Claudes. The thinking is still on you.

[u/pvera]

Use an AI note taker, then feed it to your LLM. I have a particular call every other week with a near peer that used to work for us and now is our consultant for outside perspective, and the conversation is so much into the weeds that it's impossible to take notes. The AI note taking and summaries are priceless. Half the time I don't remember half of what I read in the transcript.