Ask HN: Where is Git for my Claude Code conversations?

2 pointslil-lugger8mo ago3 comments

I’m a graphic designer who has dropped everything to build a SaaS app with a bunch of different ai coding tools and now exclusively Claude Code. I’ve been working on this project long enough that I have to re-explain business logic over and over, or I find the agent has done stuff I missed like added a new db column and I don’t know why so I revert it - but then realise it was the right thing. I keep hitting this same frustrating wall.

Then it hit me: we’re tracking version history wrong in the AI era. Or I guess, we’re not tracking it at all.

Let’s consider prompting Claude Code as its own programming language. When I write “modify out user authentication system to handle edge case X and constraint Y,” that’s not just a request - that’s source code. The actual JavaScript it outputs is the ‘compiled’ result.

But, we’re then only tracking the git history of the code base at the “assembly” level. It’s like if you could only git fetch your compiled binaries and were always throwing away all your original C code. Every time you wanted to modify your program, you’d have to reverse-engineer what you originally meant to write from the assembly output.

Why don’t we track the original inputs? The conversation contains the real logic: * Requirements and constraints * Edge cases discovered through iteration * Why we rejected certain approaches * Business context that shaped decisions

Right now, all of that reasoning just… disappears. We’re both (Me and Claude) left with just the code and have to guess at the intent.

The scale problem is real - you can’t just dump entire conversation threads into version control. A single coding session might be 50k tokens of back-and-forth. But most of that is noise. The signal is in specific moments: the user prompt, and the agent reasoning that led to each code modification.

What if we tracked it line by line? Claude Code already works line by line - when it edits code, it rewrites entire lines. We could tag every line of code with conversation IDs. Store all Claude code conversations as JSON where each prompt and agent reasoning gets its own ID. When a prompt makes the agent think and produce a tool call to edit lines -> those lines of code have its own metadata of conversation ids that directly relate to why it was written.

Imagine browsing your codebase and seeing that line 23 has 4 conversation tags. Click to expand and see: “I want to make this page only allow users who… [P_001], The user wants me to X, I should change the server file… [P_047], make sure we also include… [P_089], All tests passed but we still haven’t solved x edge case…. [P_156].”

You can trace the entire decision history behind every single line.

I’m sure there are implementation challenges I’m not seeing as a coding newcomer. We’ve figured out how to make AI write code that works - but we’re losing the most valuable part (the why) and only keeping the output.

Has anyone experimented with conversational version control? Are there technical reasons this wouldn’t work that I’m missing?

3 comments

zahlman8mo ago

> Why don’t we track the original inputs?

My suggestion is that you try using actual, literal Git for this, and then evaluate for yourself. Git doesn't care about programming language syntax. It cares about being able to feed text files to a diff algorithm.

Aside from saving versioned conversations as text files, if you have e.g. an entire commit generated from a prompt, you can include the prompt in the commit message.

lil-luggerOP8mo ago

That’s fine but you would have to find the commit message to understand the context, whereas this is closer to an extended git blame per line with more metadata because if you store the conversation history locally you can link that line to its conversation context and that lives with the code not with the git commit.

At the moment I use just extensive docs to track decisions and business logic but its static and is constantly going stale.

hammyhavoc8mo ago

Already farted around with this in using a free Cloudflare vector database for "memories" with Claude Code for a few months, but LLMs are still a dumpster fire.

You can even have it append to a local log file with what it's currently doing, what it's done in the past, conversation history et al. Doesn't really help.

If anything, by giving it more cruft to parse through, you're usually making the output even worse. You can witness first-hand how it stores credentials it fetches via the API of a secrets manager for stuff in plaintext too, despite being prompted not to do that.

They're a technological dead-end, IMO. Just code the thing yourself, or hire a pro who knows what they're doing. Total waste of time.

If you are intending to vibe code a SaaS then you're setting yourself up to get hacked to death along with a world of legal pain like that vuln disclosure post a couple weeks ago here.

"Works" is relative, and no, most of the time, it doesn't "work". It may compile, but it doesn't mean it's safe or efficient in any way whatsoever. Claude Code for example does thoroughly bizarre things that no human being would ever do. It cannot reason or deduce, and it is not a debugger.

j / k navigate · click thread line to collapse