TL;DR: Real product and delivery decisions now happen inside Claude Code sessions, and the session is a dead end by default. Auto memory is machine-local, and transcripts are designed to be cleared between tasks. The fix is a habit, not a tool swap: before a session ends, push the decisions you choose into team memory over Tandem MCP, where teammates query them and a risk check reads them back with sources. Aircall works this way and cut time from contract to cutover 30%. With 90% of developers using AI at work, the volume of trapped decisions only grows.
Ask a forward deployed engineer where their last real product decision happened. Increasingly the answer isn't a design doc or a meeting, it's a Claude Code session, somewhere around the point where the agent proposed webhooks and the FDE knew the customer's IT team would never allowlist the endpoint. The decision got made, the code got written, and the reasoning scrolled away.
A head of FDEs at a workflow-automation platform described the moment he noticed: "what about, like, the other direction? […] I'm chatting with claude code and making decisions […] Is that getting pushed into the brain as well?" His follow-up named the shape of the problem: "it's mostly just decisions I make in claude code, while I'm thinking through some solution." Not architecture reviews. Working decisions, made mid-flow, at a volume no meeting cadence ever produced.
This is a new silo nobody planned. This article covers why sessions forget by design, what a lost decision costs the people downstream, and the sync pattern that gets decisions from the terminal into memory the whole team can query.
Product decisions moved into the terminal
The decision volume shifted because the work shifted. When 90% of developers use AI at work, the place where options get weighed is the place where code gets written. For an FDE, those options are rarely pure engineering. Choosing polling over webhooks is a statement about the customer's infrastructure. Skipping an edge case is a bet about their data. Deferring a feature is a commitment someone will have to explain on the next call.
These are exactly the decisions the shared context problem is made of. They used to be captured badly in meeting notes. Now they're captured nowhere, because the meeting was between one person and an agent.
Why a Claude Code session is built to forget
None of this is a bug. Anthropic's best-practices docs advise clearing context between tasks because the window fills fast. Sessions are disposable by design, which is the right call for writing code and the wrong container for recording why.
The memory system doesn't catch what the transcript drops. As the memory docs state, "Auto memory is machine-local … Files are not shared across machines or cloud environments." Whatever Claude Code learned from your session stays on your laptop, curated for your future sessions, invisible to the teammate who inherits the account. We covered the full hierarchy in Claude Code memory for teams, and the summary is blunt: git shares conventions, nothing shares decisions.
Users have noticed. An open request on the Claude Code repo asks for a shared layer where project memory is accessible across surfaces, and the gap it names is precisely the one between a decision made in a terminal and a teammate who needs it in chat.
Meanwhile the field improvises. A founding FDE at a vertical fintech told us "whenever my claude code […] gets at 76% […] I have a ledger," a hand-maintained migration file that carries context across his own sessions. It's a good habit, and it still stops at one person and one machine.
What a lost decision costs the team
The cost lands on whoever touches the account next, and it compounds.
The engineer rebuilding the reasoning. Three weeks later someone asks why the integration polls, sees no rationale anywhere, and either re-litigates the decision or reverses it into a known failure. Engineers and their coding agents can't work well without the FDE's context, and a decision without its reason is context with the load-bearing half missing.
The handoff that turns into archaeology. When the builder changes, the handoff is only as good as the recorded state. Decisions that lived in sessions leave the successor reverse-engineering intent from code.
The status answer that forks. Sales says one thing, the tracker says another, and the truth is in a transcript nobody can search. Teams chasing a single source of truth for implementations usually think of calls and email as the missing feed. Sessions are now a feed too, and the least captured one.
Where should a session decision live?
- Spreadsheets + Slack. Findable by a teammate later: Sometimes, if the thread is remembered. Carries the reason: Rarely, and it decays in scroll. Carries sources: No. Readable outside engineering: Yes, in principle.
- Session transcript on your machine. Findable by a teammate later: No. Carries the reason: Yes, buried in full. Carries sources: No. Readable outside engineering: No.
- Claude Code auto memory. Findable by a teammate later: No, machine-local. Carries the reason: Partially, Claude-curated. Carries sources: No. Readable outside engineering: No.
- Git commit message or ADR. Findable by a teammate later: Yes, for repo readers. Carries the reason: Yes, if written well. Carries sources: Rarely. Readable outside engineering: No.
- Team memory (account brain). Findable by a teammate later: Yes, queryable in plain language. Carries the reason: Yes, stored with the decision. Carries sources: Yes, linked to quotes. Readable outside engineering: Yes, from Claude chat or Slack.
Row one is the honest incumbent, and it half-works just often enough to survive. ADRs are the best pure-engineering answer and worth keeping, but they stop at the repo boundary, and the people asking "what did we decide for this customer" mostly don't read repos.
The sync pattern: from terminal to team memory
The pattern that works treats the session as a source feeding a memory outside it. With Tandem, the AI workspace for implementation and deployment teams, that memory is the account brain, and Claude Code reaches it through Tandem MCP, the open MCP standard doing the connecting. Here's the loop.
- Work the session as you normally would. Nothing about the pattern asks you to take notes mid-flow. The decisions are in the conversation already.
- Ask for a decision summary before you close. One prompt: list the decisions made this session, each with its reason. The agent is good at exactly this kind of recall while the context still exists.
- Choose what the team needs. Usually two or three items, not twenty. A decision is worth syncing when someone else would act differently for knowing it, or when a customer heard it.
- Push your selection to the brain over Tandem MCP. The sync pushes anything you choose from the session, and only that. You trigger it, a human stays the approver of what enters team memory.
- Let the risk check read it back. Run against the brain, it returns a list of risks, each with an explanation, the reason, and the sources and quotes behind it. A decision you synced Tuesday can surface Thursday as a conflict with something sales promised.
- Answer future questions from the brain, not from memory. Teammates query it mid-session through the same MCP connection, managers and sales ask from Claude chat, and a brief arrives on demand or on schedule, in Slack if that's where the team lives.
Aircall runs this loop in production. Engineers query rollout context, commitments, porting dates, and integration decisions through Claude via MCP. Paul Yi, a senior software engineer there, described what the read side feels like: "I ask 'what's blocking the cutover' in Claude and get the actual answer, with sources."
What makes a synced decision useful in six months
Two properties separate a decision record that pays rent from a note that rots.
Provenance. A bare "we chose polling" ages into folklore. The same fact linked to the session it came from and the customer quote that motivated it stays checkable, which is what lets a skeptical engineer trust it instead of re-deciding. The same standard applies to call notes, which is why meeting notes aren't account state until they're reconciled into sourced facts.
Reconciliation. Decisions supersede each other. A memory that just appends becomes an argument with itself, so the brain has to hold the current answer while keeping the history, and surface contradictions instead of storing them silently. That's what the risk check is for, and it's the part no folder of markdown files does on its own.
What stays manual
You trigger the sync. Nothing leaves a session unless you choose it, which is a feature for judgment and a cost for discipline. The habit takes about a minute per session and it's still a habit.
Automatic resync at checkpoints isn't shipped. An FDE at an industrial-AI company asked us for exactly that, a brain that "on every checkpoint termination can, you know, resync itself back to your brain." It's a fair ask. It's also not something Tandem does today, so we say so.
Deciding what's worth keeping is yours. The tool can summarize the session's decisions, but only you know which ones a teammate or a customer will feel. And when the risk check flags a conflict, a human reads the explanation and sources and decides what to do. Every agent action here runs with a person choosing or approving it.
Make the terminal a source, not a silo
Decisions moved into Claude Code sessions and they're not moving back. The choice is whether they die at /clear or land in a memory the whole team queries. Teams that close the loop get what Aircall got: time from contract to cutover cut 30%, and the same sourced answer for whoever asks what was decided. See the loop run on one of your own live accounts, decisions in and risks flagged back, in a demo.
FAQs
Can't I just save my session transcripts?
You can, and they'll answer almost no future question. Transcripts are unsearched, unreconciled, and stuck on your machine, so the teammate who needs the polling decision won't find it inside three hours of scroll. Team memory stores the decision, its reason, and its source as a fact anyone can query in seconds.
Doesn't Claude Code's auto memory already capture my decisions?
It captures some learnings, for you, on that machine. The docs are explicit that auto memory is machine-local and never shared across machines or environments. It improves your future sessions and does nothing for your team's.
Which decisions are worth syncing?
Ones someone else would act on: anything a customer heard, anything that constrains the architecture, anything that changes scope, dates, or risk. A good test is whether the decision would come up on a handoff call. Most sessions produce two or three, many produce zero, and syncing zero is a fine outcome.
Does the sync happen automatically at checkpoints?
No. Today you trigger it and you choose the contents. Checkpoint-triggered resync is a request we hear from users and haven't shipped, so plan for the manual habit.
Can people outside engineering see decisions synced from sessions?
Yes, that's most of the point. Managers and sales query the same brain from Claude chat, and briefs can be delivered anywhere including Slack, so the decision you made mid-session reaches the account manager without a status meeting.
Key terms
Team memory: account-level memory that survives crossing people, machines, and tools. The destination sessions should feed.
Shared context: what a team has when its members and agents get the same sourced answer to the same question. See the pillar for the problem it solves.
Decision provenance: the trail from a recorded decision back to where it happened and why, sources and quotes attached. What makes a record trustworthy later.
Account brain: Tandem's product part, a source-linked memory per customer account with risk detection, Tandem agents, and a customer workspace.
Risk check: a Tandem query that returns a list of risks, each with an explanation, the reason, and sources. Reads synced decisions against everything else the brain knows.
Auto memory: Claude Code's machine-local, self-curated memory. Useful to you, invisible to your team.
Tandem MCP: the MCP server connecting Claude, Claude Code, or ChatGPT to the account brain, for queries in and chosen syncs back.