The Hidden Cost of Our Commit-Only Workflow

Software development is currently trapped in a snapshot paradigm. We treat code as a series of discrete, static artifacts, known as commits, while ignoring the high-entropy process that takes place between them. Nathan Sobo, founder of Zed, argues that this focus on the end product over the collaborative process creates a massive blind spot. By treating the space between commits as discardable noise, we lose the context of agent-human collaboration, the rationale behind architectural shifts, and the ability to trace code back to its original intent. This conversation reveals that the next competitive advantage in tooling is not just a faster editor; it is the transition from snapshot-based versioning to continuous, event-sourced collaboration. For engineering leads and developers, the advantage lies in capturing the dark matter of development, which includes the conversations and edits that define how software is actually built.

The Illusion of Standardization

We often mistake market dominance for technical superiority. In the browser wars, the shift toward a Chromium monoculture was framed as standardization, but as Sobo notes, it actually resulted in the loss of diverse approaches and the imposition of lowest-common-denominator APIs. This pattern repeats in development environments. When teams default to the most popular tool simply because everyone else uses it, they often inherit the performance and architectural limitations of that tool foundation.

The truth was, when I started out, I might have really did not know what I was doing. Luckily that is different thanks to a decade plus of grinding on these problems and learning about the fundamental data structures that makes text editing actually work... But VS Code just took over. And I think then it just becomes a tale of feedback loops.

-- Nathan Sobo

The danger here is that teams optimize for the immediate convenience of the status quo while ignoring the long-term cost of working within a constrained, single-threaded, or memory-heavy architecture. Building something superior requires the patience to question fundamental foundations, a path that feels less productive in the short term but creates a durable moat over time.

Why the Commit is an Incomplete Artifact

The current industry standard, Git, is built on a directed acyclic graph of snapshots. While efficient for transferring data, it fails to capture the process. When developers work with AI agents, the real value is not just in the final diff; it is in the conversational stack tracing, which includes the back-and-forth, the abandoned attempts, and the steering that led to the solution.

By failing to version these interactions, we create a context gap. A colleague reviewing your code sees the result but misses the entire decision-making journey. This creates a downstream tax: the reviewer must spend time reverse-engineering the intent, or worse, they miss critical context that would have prevented a regression.

There is an assumption that the only code worth talking about is the green and red lines. And we don't believe that.

-- Nathan Sobo

DeltaDB aims to solve this by versioning the process itself. By treating every keystroke and agent interaction as a durable event, it turns the code into a collaborative canvas. This allows team members to step through the portal of a specific conversation, seeing exactly how the code evolved at the moment of creation, rather than squinting through a static diff.

The Trade-off: Provenance vs. Surveillance

The transition to continuous, event-sourced versioning introduces a new tension: the thin line between code provenance and workplace surveillance. If every edit and agent prompt is recorded, does the system become a tool for judging how a developer spends their day?

Sobo approach suggests that the solution is not to stop recording, but to design for finer-grained control. The goal is to allow developers to decide which parts of the process are shared and which remain private. By allowing for compaction or summarization of the raw edit history, teams can maintain the benefits of a full audit trail without the social cost of constant monitoring. This requires a shift in mindset: moving away from the assumption that you must always store everything in a public-facing way, and toward a model where the availability of data is decoupled from the exposure of that data.

Key Action Items

• Audit your context tax: Over the next month, track how much time your team spends explaining the why behind changes in pull requests. If this is a recurring bottleneck, recognize it as a symptom of snapshot-based versioning.
• Decouple your tooling from the monoculture: Evaluate whether your current IDE is actually serving your team specific needs or if you are simply following the herd. Invest in tools that allow for higher-level abstractions, such as operation-level tracking, rather than just faster text editing.
• Adopt conversational documentation: Start treating your AI agent logs as valuable artifacts. Even if you are not using event-sourced tools yet, consider attaching the why of your agent-assisted work to your commits to reduce the cognitive load on future reviewers.
• Prepare for event-sourced workflows: As tools like DeltaDB mature over the next 12 to 18 months, begin identifying which parts of your current development process are hidden, such as agent steering or manual exploratory edits, and start treating them as first-class, versionable assets.
• Establish privacy boundaries for AI interaction: If your team uses AI agents, define clear policies on what constitutes a shared conversation versus a private scratchpad to avoid the discomfort of perceived surveillance as tooling becomes more granular.