“What’s the coding style here?” “Should I write tests first?” “What does ‘done’ mean in this project?”

Every. Single. Time.

Still, I’ve been living with this for months. Sure, I’d write CLAUDE.md files for every project, but they’re only as good as what I remember to put in there. But my actual coding habits — the things I do without thinking — never made it into those files.

The shortcuts I take. The patterns I instinctively reject. The way I actually debug, not the way I think I debug.

Then I found Ditto — a Python tool that digs through your real Claude Code and Codex session logs and mines them into a personal you.md profile. Not based on what you think your style is. Based on what you actually did.

So I ran it on my last 3 weeks of sessions. The result shook up how I think about agent personalization.

Want to share your Ditto profile with your team so everyone’s agent speaks the same language? Hosting a central you.md on a cheap VPS is the easiest way. DigitalOcean gives new users $200 in credit — enough to run a profile server for over a year. Drop your you.md on a static file server and point everyone’s agent config to the same URL. (affiliate links)

The Short Version

Ditto (149★, MIT, Python) reads your coding agent session logs — from ~/.claude/projects and ~/.codex/sessions — and extracts the implicit rules you follow. Now the output is a you.md file your agents read before every task. One pip install, one command, and your agent finally knows how you actually work.

But here’s what makes it different: instead of guessing your style from a questionnaire, Ditto builds your AI coding agent personality profile from real keystrokes, rejections, and shipping habits. Not what you say you do — what you actually did.

Why This Matters More Than You Think

Here’s the thing about CLAUDE.md: it’s you telling your agent who you are. But most of us are terrible at self-documenting. So we write “follow best practices” when we really mean “don’t add unnecessary abstractions.” Plus, we write “write tests” when we really mean “write tests for business logic, skip the boilerplate.”

But Ditto flips this. So instead of you writing a personality guide for your agent, it reads the evidence — every message you sent, every decision you made across hundreds of sessions — and builds the profile from actual behavior.

So this isn’t about making your agent smarter. It’s about making it yours.

Still, I tested this on my own history. Now, I’ve been using Claude Code heavily for about 3 weeks across 6 different projects. That’s roughly 40-50 sessions with maybe 1,200+ messages. I ran Ditto on the whole lot. But I didn’t expect it to surface things I didn’t know about myself.

Quick Start — It’s Embarrassingly Easy

pip install ditto-agent

That’s it. And the whole thing is zero-dependency Python. No Docker, no Node, no Rust toolchain. Pure Python, one command.

Then you point it at your session logs:

python ditto.py --mine

It auto-scans ~/.claude/projects and ~/.codex/sessions. On my machine it chewed through about 3 weeks of logs in under a minute. The output lands in a ./ditto_output/ folder with a you.md file.

Now you need to get that profile into your agent’s workflow.

python ditto.py --install you.md --target claude

This sets it up as a Claude Code skill. Next session, your agent reads the profile before touching anything.

And here’s the cool part — the archetype card:

python ditto.py --card

This renders a shareable card with your coding archetype, top rules, and a brutally honest observation.

So I stared at the output for a solid minute before it sank in.

What Ditto Found About Me

I ran --card and got back something that made me laugh out loud:

Archetype: Builder-Explorer Top Law: “If it compiles and passes the critical path, ship it. Edge cases get tests after launch.” One Sharp Truth: You say you value test coverage. Your actions say you value shipping speed. Your agent has been confused by this contradiction.

That last line hit hard. Because it’s true. I tell my agents I care about tests, but my actual behavior shows I care about getting the damn thing out. Ditto exposed a gap between my stated preferences and my actual behavior — a gap my agent was silently living with for weeks. So that’s the thing about mining your own data: it doesn’t lie.

Top 5 extracted rules from my sessions:

Coverage stats: 73% of sessions aligned with these top 5 rules. The remaining 27% were edge projects where I intentionally broke my own patterns.

Though I should mention these are just the top patterns — the full profile had about 20 rules covering everything from commit frequency to error-handling style.

Still, seeing yourself summarized this cleanly is humbling. Your agent can finally stop guessing.

How It Works Under the Hood

Still, Ditto is surprisingly not complicated. No LLM dependency, no external API calls. Here’s the pipeline:

1. Scan — Reads ~/.claude/projects and ~/.codex/sessions JSONL files

2. Extract — Pulls only your messages (not the agent’s). Secrets are redacted with a regex filter before anything touches disk.

3. Chunk — Splits your messages into logical blocks per session

4. Analyze — Extracts explicit patterns: commands you repeat, decisions you flag, approvals you give

5. Compile — Ranks patterns by frequency and consistency, writes them to you.md

The you.md file itself is clean Markdown with three sections: Core Identity (your archetype + top laws), Behavioral Patterns (recurring decisions), and Communication Style (how you give feedback).

But the real magic is in step 4 — extracting patterns from what you actually did, not what you planned to do. I read through mine and it was eerily accurate. Every rule it extracted was something I do but never wrote down.

So here’s how Ditto stacks up against the alternatives:

Comparison: Ditto vs the Alternatives

Where Ditto Falls Short

Now, I want to be honest about the limitations I hit.

1. It needs volume. I had about 40 sessions across 3 weeks, and it worked well. The author recommends at least 100 sessions for meaningful patterns. If you’re new to coding agents and have less than a week of history, the output will be thin.

2. It can’t read your mind. Ditto mines what you did, not why you did it. If you had a bad day and rejected perfectly good code, that goes into the profile. The “one sharp truth” feature catches some of this, but you’ll want to review the output before installing it.

3. Cross-project patterns can clash. I work differently on side projects vs. production code. Ditto blends everything. There’s no project-level profiling yet — your you.md is a single averaged version of you.

4. No –uninstall. If you install it and change your mind, you have to manually remove the skill from your Claude Code config. A minor annoyance, but worth knowing.

Even so, none of these are deal-breakers. But even with these quirks, the core idea is solid enough that I’m keeping it installed.

Real-World Scenario

Here’s where Ditto shines: onboarding a new project.

So say your teammate used Claude Code to refactor the auth module while you were out. You come back, open a fresh session, and start reviewing. Without Ditto, your agent has no idea what you care about. It starts suggesting abstractions you’d reject. It writes verbose tests when you’d prefer focused integration tests.

With Ditto, your agent reads your profile first. It knows you value shipping speed over architecture purity on this team. It knows you want integration tests over unit tests for API routes. Your review session is immediately tighter because the agent isn’t guessing your preferences.

But here’s the real test: I actually ran this. So I had a session where my agent wanted to introduce a service layer for a 3-endpoint API. My Ditto profile says “no abstractions until 3rd repetition.” The agent read that, skipped the service layer, and went straight to implementation. So it saved me about 10 minutes of back-and-forth.

Who Should Use Ditto

• Heavy Claude Code / Codex users — If you have 100+ sessions, Ditto will surprise you with what it finds
• Teams standardizing agent behavior — Share a team you.md so everyone’s agent speaks the same language
• Anyone tired of re-explaining themselves — You write your preferences once. Ditto extracts them from your history. Your agent remembers.

Still, skip it if you use coding agents less than once a week, or if you’re already happy with your CLAUDE.md setup.

But if you’re on the fence, here’s my take: you’ll learn something about yourself.

The Bottom Line

Yet Ditto is one of those tools that seems small until you see what it does. It’s not adding a new feature to your agent — it’s making your agent actually understand you. From your real data. With zero configuration.

Plus, I went from “eh, I can just write a CLAUDE.md” to “I can’t believe I was doing this manually” in about 30 seconds of running --card.

So here’s my honest take: install Ditto. Run it once. Read what it says about you. Your agent will thank you.

Need a cloud server to host your team’s agent profiles or run Ditto across centralized session logs? Vultr offers a $100 trial for new users with 32 global datacenter locations — deploy your profile server in under a minute.

What’s Next

If Ditto got you thinking about agent personalization, there’s a whole world of material on making AI coding agents actually understand you. Two books I keep coming back to:

• “Designing Agentive AI” — covers the philosophy of agent-user relationships and why personalization changes everything
• “Prompt Engineering for Developers” — practical patterns for shaping agent behavior, including profile-based prompting

Both dig deeper into the ideas Ditto surfaces from your logs. Worth a read if you’re serious about making your agent yours. Yet it’s the practical application that matters most.

On a tight budget? Hostinger KVM VPS plans start at $3.99/mo — more than enough for a lightweight Markdown file server to host your team’s you.md profiles.

FAQ

Does Ditto send my data anywhere? No. Everything runs locally on your machine. Session logs are read from your local ~/.claude/projects directory and the output stays on your disk. Secrets are redacted before processing.

Can I share my profile across my team? You can — host the you.md on a shared drive or a simple web server. A $6 DigitalOcean droplet is plenty for this. Point everyone’s agent config to the same URL.

Does it work with Cursor or Gemini? Yes. Ditto supports Claude Code native, plus Codex, Cursor, and Gemini CLI. The --install flag auto-detects the target.

Do I need to stop using CLAUDE.md? Not at all. Ditto and CLAUDE.md complement each other. CLAUDE.md is for what you know about yourself. Ditto is for what you don’t.

Earlier today I covered mindwalk, which shows you WHAT your agent did. Ditto flips the question around — it teaches your agent WHO you are. Together they form a complete picture of agent observability and personalization.