Training Claude on the Job

How I built a system that carries what Claude learns about me from one session to the next.

The Problem

Claude Code doesn't remember you. Every session starts fresh. You can spend an hour getting it calibrated — your writing style, which tools you prefer, what you've already tried, what didn't work — and the next day it's gone. You're re-explaining the same things to a blank slate.

For casual use that's fine. For someone using it daily as a core part of how they work, it adds up.

How I Think About It

The mental model that helped me most: think of Claude as a new employee you're training on the job. They're capable. They pick things up fast. But they need context about how you operate, what your standards are, what you've already decided. Without that, they default to their own judgment, which is often good but not calibrated to you.

The difference is that with an actual employee, that training happens passively over months. With Claude, I can make it deliberate and structured.

How It Works

At the end of a session, I run a command called /distill. It reviews what happened in the conversation and surfaces anything worth keeping — a preference I stated, a pattern I corrected, a tool behavior I confirmed. It proposes each one individually as a change before writing anything. I approve or reject. Nothing gets saved without my sign-off.

Those learnings go into a versioned repo that loads automatically at the start of every new session. Over time, Claude arrives with more context: which LinkedIn structures I've passed on, which chart library I've standardized on, how to route to Gemini instead of Claude to save cost. The calibration accumulates rather than resetting.

What Gets Captured

• —Writing patterns I've corrected — for example, I flagged that curiosity-gap hooks on LinkedIn posts feel manufactured regardless of how they're phrased, with the specific constructions noted and why each one was rejected
• —Model and tool preferences — which model for which task, when to route to Gemini instead of Claude to save cost
• —Workflow decisions — how I like to structure certain tasks, what order I want things done in
• —Error patterns — things that have gone wrong before and how I resolved them

None of it is permanent. If something turns out to be wrong or outdated, I update or remove it the same way it was added.

The Portability Piece

Since it's a git repo, it's not tied to one machine. I pull it onto any device and the context comes with it. It's also selective — I can export just my writing style rules to share with a collaborator, without including API keys or personal config. That kind of partial export isn't possible with any of the automated tools.

Most “memory” features in AI tools are account-level and cloud-synced, which means you're trusting the platform to maintain them and decide what matters. This one I own and version myself.

Why Not Just Use the Built-In Memory?

Claude Code has auto memory. It's on by default and does persist across sessions. So this is a fair question.

Auto memory works by having Claude decide what's worth saving as you work. It writes notes to itself about patterns it notices, commands you use, preferences you express. The problem is the lack of a filter. Claude is making judgment calls about what matters without you reviewing them. Over time the memory fills with things that were relevant once, half-formed observations, and context that no longer applies. There's also no version history, and it doesn't follow you to another machine.

Distillation sits on top of that gap. Nothing gets written without you approving it. The learnings are categorized by type, versioned in git, and available wherever you pull the repo.

What About Skills?

Skills are procedural. They tell Claude how to execute a specific task — how to commit code, how to review a PR, how to run a deployment. They load based on context or when you invoke them directly.

What gets captured through distillation is different. It's calibration: what writing patterns you've rejected and why, which tools you've standardized on, what you've already decided so you don't have to decide it again. Skills and distillation aren't competing — they solve adjacent problems.

This Isn't a New Idea

Other people have built versions of this. Anthropic staff use a diary and reflection system to auto-update their context files. There are open-source plugins that capture session context, compress it, and inject it back automatically.

Most of those systems are fully automated. The thing I value in my version is that nothing saves without my approval. Automated memory accumulates wrong things confidently. The approval gate is the point.

The Bigger Principle

The goal was never to make Claude smarter. It was to stop wasting time re-establishing context that already existed — and to own that context outright rather than depending on a platform to maintain it for me.