One thing makes a practice trustworthy: you can see exactly what it did, when, and why, all the way back to when it started. That is a record problem, and git is the best record-keeping tool we have. Branches for trying things out, commits for capturing a point in time, notes for attaching context, and a history that cannot be quietly edited after the fact. The work runs on git so you never have to.
The pieces are already there
git commit Captures a state
Each step of the work is pinned to a point you can always return to.
git branch Explores an idea
Trying an approach without committing to it, the way real thinking forks and backtracks.
git merge Settles on an answer
Competing ideas resolve into one clean line once a decision is made.
git log Keeps the history
The full record of what happened, in order, that you can read back at any time.
git notes Attaches the context
What the AI knew and decided, attached to the exact commit it belongs to.
git diff Shows what changed
The difference between where the work started and where it ended up.
Why git, and not a database
Real reasoning is not a straight line. It explores, forks, and backs out, and git was built to track exactly that shape of change. Just as important: in a database, history gets overwritten. In git, the chain of what happened is held together by hashes that cannot be tampered with after the fact. When you ask why the AI did something, the answer is on the record, and the record is provably the real one.
Where the record lives
Four layers, from the live session in memory down to the permanent history in your repository. Each one can rebuild the one above it, so nothing important is ever really lost.
The current session
In memory
What the AI is working on right now: its current state, active goals, and context. If a session crashes, this is rebuilt from the layers below.
The local database
Fast queries
Sessions, decisions, findings, and goals, stored so you can ask things like 'what did we get wrong last week' and get an answer in a moment.
Semantic memory
Recall by meaning
Facts and past session stories you can search by meaning, not just keywords. 'Find everything we learned about caching', across every session.
Git notes and logs
Travels with the repo
The durable record attached straight to your commits. It moves with the code when you clone or share it, and it cannot be quietly rewritten.
No new concepts to learn
Every step maps to a git command you already trust. Nothing exotic underneath, just careful engineering on top of tools that have been proven for fifteen years.
| What the AI is doing | Git command | What it means |
|---|---|---|
| Capture a state | git commit | Pin this point of the work with a hash you can return to |
| Explore an idea | git branch | Fork a line of work to test an approach |
| Settle on an answer | git merge | Fold the validated work back into the main line |
| Back out | git checkout | That did not work, return to a known-good point |
| See the change | git diff | Measure the distance between what you knew before and now |
Why it matters
Building on git means the history is auditable by anyone who can read a repo, it survives long after the conversation that made it, and no one can rewrite it without leaving a trace. That is the foundation the whole thing stands on, and it is open for inspection.
See how a piece of work is structured →