Cole Medin (17 min) argues the most underused asset in an AI coding setup is the transcript graveyard on your own disk — every conversation with your agent, already written to a file, and almost never read back.

The premise

  • Every conversation your coding agent has is stored as a file on your machine — Claude Code writes JSONL, split by project.
  • Those files hold every prompt you sent, every tool or MCP server the agent called, every thought it had.
  • The agent already knows this — ask “where are all Claude Code conversations stored?” and it can point you at the folder. Cole finds agents reach for those files even when a separate memory system exists, because they’re that rich.
  • The blocker is volume: thousands of these files are too messy to read by hand — and Claude Code deletes them after 30 days by default.
  • So the setup needs two things: somewhere transcripts live permanently, and a database that turns them into structure (sessions, turns, tool calls).

The two-sentence version

  • Just ask: do a deep dive into past conversations, identify opportunities to make the agent more efficient or reliable, suggest the top 10 improvements as a concise bullet list.
  • Bounding the output matters — before Opus 5.5 he’d get “a million different things that barely mattered at all.”
  • It loads a skill he built for the process and runs shell commands across the files.
  • Real example it surfaced: hitting the concurrent sub-agent limit constantly. Follow-up prompt — “what can I change in our AI layer to fix issue #3?” — pointed at the specific sub-agent responsible.
  • His definition of AI layer: sub-agents, hooks, rules, skills, and the rest of the .claude folder. It’s written into the skill so the agent knows it’s auditing itself.

Why that approach hits a wall

  • The agent either reads hundreds of thousands of tokens of JSONL to find every pattern, or it cherry-picks a few files and returns surface-level findings.
  • Neither is reliable, and you re-pay the token cost every time you ask.
  • He name-checks existing options (CC usage, Claude Mem) but says they’re memory systems, not instruments for making the agent measurably more efficient over time.

The real system: volume + tables + Genie

  • Install the Databricks CLI, connect it to your coding agent of choice (Claude Code, Codex, Pi) as an MCP server.
  • Create a volume in Unity Catalog and upload the transcripts — either through the MCP server or plain drag-and-drop.
  • Point Genie (Databricks’ built-in agent) at the volume path and have it process every JSONL with Spark instead of burning model tokens.
  • He flagged the hard part honestly: the session transcripts have “inconsistent nested schemas across records” — every conversation is formatted a bit differently.
  • Two-step prompting he recommends: first make Genie understand the data and prove the shape back to you, then have it create the tables and load everything.
  • Result: turns, tool_calls, and sessions tables, populated, with row counts and columns reported back. He says he wrote none of the generated code.
  • Then query from your coding agent through the MCP server — Claude Code becomes the orchestrator asking questions, Genie is the brains writing SQL over structured data.

The privacy caveat he raises himself

  • You’re uploading coding-agent conversations into a third-party platform — he says be okay with that before starting.
  • Databricks doesn’t train on the data, and the bar is that you shouldn’t be handing sensitive material to a coding agent in the first place.
  • If your JSONL files carry API keys, scrub them first — the MCP server can do the scrubbing before upload.

What he actually changed

  • +38 lines of global rules targeting the failure patterns Genie surfaced — including “never guess a path,” which he says agents do constantly if you don’t forbid it.
  • More permissions in settings.json so the agent works with Git more cleanly.
  • A hook (his favorite change): a session-tree script that fires at the start of every conversation and injects the real repository layout, so the agent stops guessing paths while gathering context.
  • Why a hook beats a rule: a codebase layout hard-coded in global rules goes stale and has to be maintained by hand — injected at runtime, it’s always current.

“Your past conversations with your coding agent are a gold mine. There are a lot of different ways to structure the conversations and gather insights from them and act on them.”