Git history is commit theater
The first time it really bothered me was a JWT compat shim our auth refactor agent considered for a few seconds and then walked away from. The shim looked correct. It would have worked for a few months and broken on the next key rotation. The agent caught what I would have caught reading the code, then squashed the consideration out of the commit. The reviewer reading the diff would have seen a clean refactor and approved it. The decision the agent actually made, to back out of the shim, was nowhere on the artifact.
I'm the engineer behind Heddle, and this kept happening. Different agents, different refactors, same pattern: a moment of real reasoning got curated out of the record before anyone could read it. So I started building something that doesn't curate.
Git's instinct is to throw the messy middle away before committing. Squash to a clean diff, write a polite message, pretend none of the rest happened. That instinct made sense for thirty years because a human writing code throws away false starts as fast as they make them. The cleanup cost stayed small.
But the volume changed. An agent on the same refactor produces a lot more artifacts than I would: captures, retries, abandoned paths, test runs that disagree for reasons I haven't yet rooted out. The cap isn't human attention any more. It's token budget, and token budget keeps growing.
What we built keeps the rejected approaches around. Each capture is tied to which agent made it and when in the run, so the JWT shim ends up in the record alongside the diff, not as code, just as a captured consideration the agent discarded. Or that's the shape, at least.
Two things have started to puzzle us about it.
The first is that the abandoned approaches turn out to be useful in a way I can't quite explain. It's not just "this was tried before." There's something about who tried it and when (the fact that the JWT shim was rejected by Claude at hour two of a refactor and is now sitting in the trail when a teammate is about to propose something similar) that changes how the team treats the proposal. We've started calling these "considered-rejected" decisions in conversation. The name is provisional. I haven't quite worked out what makes them different from "things we discussed and decided against in a meeting", but they feel different.
The second puzzle is the failure mode. When an agent goes sideways for a few hundred captures on a refactor that wasn't going to land, the trail gets harder to read. Not noisy in the signal-to-noise sense. It's scannable, attributable, well-structured. Harder in the way a transcript of someone thinking aloud is harder than a clean retrospective. You have to do real cognitive work to follow what was being weighed. Reading the transcript is more information than reading the squash, by a lot. We're not sure when more is too much.
Git was built around the assumption that the rehearsal was small enough to discard. That assumption isn't right for agent-driven work, but what replaces it isn't obvious. The trail feels right when I'm reading one I haven't seen before. It feels overwhelming when there's been a few hundred of them in a week. The version that scales might not be what we shipped to ourselves last month.