Last year, a commit meant a human made a decision. Now it might mean an AI agent tried 47 variations of a function before picking one - and none of that exploration shows up in your repo's history.
That's the central argument coming from the team at agent-undo.com, who've been thinking about what it actually means for an AI agent to be a contributor to a codebase. Their case: AI coding agents aren't just a faster way to write code, they're a different kind of contributor entirely - one that Git was never designed to handle. Worth reading with the caveat that they're building tooling in this space, which shapes their framing.
Where the Model Breaks Down
Git tracks changes by who made them and when. It assumes each commit represents an intentional decision by a human contributor. An agent like Cursor or Claude Code doesn't work that way. It might generate a thousand lines of code, discard half mid-session, try a different architecture, backtrack, and produce a final result that commits cleanly. What Git records is the output. The process - all the attempts, the discarded approaches, the reasoning behind the final design - is gone.
This matters more than it sounds. When a change causes a bug three weeks later, developers rely on git blame and commit history to understand intent. With agent-generated code, that history often says nothing useful. The commit message reads "implement feature X" and the diff looks like a normal change. The reasoning that produced it exists only in an ephemeral conversation that closed when the session ended.
The parallel work problem is also real. Agents can explore multiple approaches simultaneously - spin up five different implementations and pick the best one. Git supports parallel branches, but all the tooling around those branches (code review, diff visualization, conflict resolution) assumes human-scale branching, not five competing agent experiments.
Working Around It Now
Some teams have started treating agent sessions like architectural decision records. They log the prompt, the model, and key reasoning into a structured commit message or a companion document. Others run agent work on isolated branches and do a manual squash-and-rewrite before merging, translating the agent's output into a human-readable commit history.
These are workarounds, not solutions. The actual fix is probably tooling that sits between the agent and Git - something that captures the agent's decision process, the prompts that drove it, and the alternatives that were rejected. Agent-undo.com is building checkpoint and undo functionality for agent sessions. Cursor, Aider, and Claude Code all have internal session histories that already exist alongside - not inside - Git.
For now, if AI agents are part of your development workflow, treat your Git history as a record of outputs, not a record of process. The reasoning lives in your prompt logs, your agent session history, and your code review notes. git log will tell you what the code looks like. It won't tell you why.