We need to get over Git

We need to get over Git.

Last year it came into my mind: is Git really the best solution? We are relying on it just because we’ve done it since ever, right? That was before I created my first worktree, before this whole agentic coding era. Even back then it somehow felt clunky, like bureaucracy: you need to create commits (I never found a good strategy of scoping them), need to push, somehow fight local changes against upstream, stashing, branching. It suddenly just didn’t feel right anymore.

It didn’t feel like a tool helping me build software anymore, more like paperwork. Then agents arrived, and it got really obvious.

TL;DR

• Git’s ceremony (commits, branches, stashes, PRs) is a coordination protocol for a world where human work was expensive, serial and full of handoffs
• Agents broke every one of those assumptions: work is cheap, parallel and continuous. The ceremony didn’t adapt, it just became overhead
• Git the database (content-addressed snapshots, distributed sync) is fine and will survive
• Git the workflow is what has to go, and agent harnesses are already quietly replacing it with checkpoints, worktrees and review loops
• I built an experiment to test this: ChangeLedger, where the change is the primary object and a Git commit is just the export format

What Git actually is

Strip the habit away and Git is two things bolted together:

1. A database: content-addressed snapshots of your tree, with cheap diffing and distributed sync. This part is genuinely great.
2. A coordination protocol: commits as units of human intention, branches as units of human ownership, PRs as units of human review, stashing as a workaround for humans doing one thing at a time.

We treat the second part like a law of nature, but it’s just an interface, designed around the constraints of 2005: human labor is expensive, so every change deserves a hand-written message. Humans work serially, so you need stash and branch juggling. Handoffs between humans are the bottleneck, so you build a whole ceremony (the PR) around them.

Ever noticed that nobody actually has a good answer for how to scope a commit? “Atomic, but not too small, logically complete, but reviewable.” Twenty years and the best we have is vibes. For me that’s a sign the concept itself doesn’t really fit the work.

Agents broke the assumptions

Every constraint the ceremony was built for is gone:

• Work was expensive → now it’s cheap. When an agent produces hundreds of changes an hour, hand-scoped commits with hand-written messages just don’t scale anymore.
• Work was serial → now it’s parallel. My first worktree was the moment this clicked for me: suddenly five agents work five tasks in the same repo without fighting each other. Stashing (this whole “local vs. upstream” wrestling) only exists because one human, one working copy, one thing at a time. That world is over.
• Handoffs were the unit of review → now loops are. Agent work gets reviewed continuously by other agents while it happens, not once at the end by a colleague who context-switches into a 40-file diff. The PR boundary sits at the wrong place in the wrong rhythm. (I even skip branches and PRs completely for fully agentic work, because the ceremony protects a handoff that just doesn’t happen there.)

What stays genuinely valuable is none of the ceremony: it’s checkpointing (“return to any earlier state”), provenance (“which session changed this and why”) and gating (“what’s allowed to reach production”). Git the database does checkpointing well. The ceremony does provenance and gating badly: a commit message is a worse record than the full agent transcript that produced the change.

It’s already happening

Look closely and the replacement is being built, just not announced as one. Agent harnesses auto-checkpoint every step, so you can rewind without ever having “committed”. Worktrees turned the one sacred working copy into disposable parallel sandboxes. Stacked-diff tools like Graphite exist because raw branch/PR mechanics already don’t fit how work flows. And Jujutsu quietly made “every edit is automatically a snapshot, describe it later, reshape history freely” feel normal, on top of Git’s database, with Git’s ceremony removed.

That’s the pattern I would bet on: nobody “replaces Git”. Git sinks one level down and becomes plumbing (like TCP/IP: nobody thinks about it, it’s just there). The layer we actually touch becomes: continuous checkpoints, parallel sandboxes, session-level provenance and review loops instead of review handoffs. The resistance to this will be loud, because Git fluency was hard-earned. I get that, mine was too.

I got curious enough to build it

At some point complaining wasn’t enough, so I started an experiment to see what the layer above Git could look like. I call it ChangeLedger: change-native development infrastructure, where the product change is the primary object, not the commit.

The model, in one line:

Intent -> Change -> Operations -> Checkpoints -> Evidence -> Git export

A change carries its goal, constraints, decisions and rollout state. Every mutation is an attributed operation with a stated intent. Every checkpoint is an immutable source tree, created continuously, never hand-scoped. Verification results attach as typed evidence to the claims they support (“cancellation behavior is correct” → the test run that proves it). And Git? Git is the export format: one squashed synthetic commit per approved, integration-ready change, generated at the end. Exactly the demotion from the last section: workflow above, plumbing below.

And look what dissolved on the way: nobody scopes commits (checkpoints are continuous, the change is the unit). Nobody writes commit prose (intent was declared up front, evidence is attached, the message is derivable). And nobody stashes (ordinary files are just a workspace projection of the ledger’s objects).

It’s a runnable local MVP, not a product. The point was never to ship a Git killer, I wanted to check if the ceremony is actually load-bearing. Spoiler: it isn’t. Everything valuable (checkpointing, provenance, gating) got stronger when intent and evidence became first-class and commits became output.

What I actually do today

I’m not waiting for the successor to be announced. The pragmatic version, today:

• Fully agentic work skips the ceremony. No branch, no PR, no hand-scoped commits: the agent loop with reviews is the quality gate. The ceremony only earns its cost where a real human handoff happens.
• Worktrees by default for anything parallel. The single working copy is a habit, not a requirement.
• Provenance over commit prose. The session and its transcript are the real record of why a change exists. Commit messages become labels, nothing more.
• Let the harness checkpoint. I stopped creating safety commits “just in case”, the tooling already snapshots continuously.

None of this abandons Git. It demotes it, from workflow to storage.

We don’t owe Git our workflow. It was built for a world where typing was the expensive part, and that world is gone.