Software Is Made Between Commits

I really don't like this. The code I write between commits is my thinking. I think by writing some code out, deleting it, writing again. The code I write that's shipped in commits is written for others to understand, and is a product of that writing for thinking process.

I don't want my thoughts to be serialized, version controlled and publicly accessible.

https://www.nature.com/articles/s44222-025-00323-4

I can see how this is a great building block for what Zed is doing around collaboration.

One thing I would really love to see, however, is a way to better attach code review comments to the specific version of code they were left on. I find it quite difficult to do with git and github, considering that commit hashes change every time one is forced to rebase (say, for example, to handle a merge conflict).

Do you expect DeltaDB to help address this problem?

I would be interested in a clear statement about how this scales. I've not used this workflow myself, but I've seen teams that did it. Whether they got huge benefits out of it I don't know, but I do know that watching them, I was not jealous of what I saw. If I make a change, and I run some tests that were passing a moment ago, and they fail, and the reason why they failed is that Bob hit "save" on his editor (or his editor autosaves) and he made a syntax error in a shared library, and this happened often... I would go insane. I cause enough problems for myself without other people's problems actively intruding at uncontrolled times into my tests.

AI's code writing velocity makes this even worse, there's no way I can be simultaneously working on a code base while an AI agent is running around it doing something else.

It feels like maybe there's a ghost of an idea here about how to get the best of both worlds, but I'm not sure I follow the throughline on it.

Google has been doing this for maybe a decade now with citc [0]. I don't know when Gemini is actually going to be taking advantage of this, but I do know that google has essentially a full history at "Ctrl-S" granularity, from ~every developer that works there, for at least 10 years now.

If Gemini seems stupid nowadays, it's only because they're being stingy with compute allocation.

0 - https://en.wikipedia.org/wiki/Piper_(source_control_system)

There are so many early-stage startups also competing in this space right now. I’ve been on the interview circuit the past few weeks and talked to at least two. It’s going to be stiff competition for any of these tools to get well-established enough to be successful at a large scale.

I can’t help but feel like it is all enabling a level of developer surveillance with which I am deeply uncomfortable, though.

I have an uneasy feeling in my stomach because i know anthropic or openai acquiring zed is inevitable. They have too many good ideas and their software is too good.

What is apparent to me is that we are moving towards dark factories if the promise of LLMs writing most of the code is fulfilled. So this means that it is less about conversations and it is more about iteration.

A bit O/T but:

> I have never been a big fan of pull requests.

I guess this partly explains why Zed (still) lacks a PR review flow, let alone a coherent one, despite some interest [1]. Pretty much the only reason I’m still with JetBrains.

[1]: https://github.com/zed-industries/zed/discussions/34759

> What we're really after is simple: the conversation with the agent becomes the only conversation you need to have.

This benefits those who make the machines you have conversations with and those that invest in them.

A commit is useful because you cleaned it up first. The messing around in between is where you try things and delete the dead ends and most of it is meant to be thrown away. Saving every change and every agent message keeps all that junk around instead.

Sad to see zed going the same route everybody is screaming them not to. Altough, I never expected otherwise.

I don’t see the value proposition here. I’ve seen roughly this feature proposed by multiple companies, and absolutely none of the have given a convincing reason for the technology to exist.

so i think the thing that everyone building these git alternatives is missing is a multi-repo story - unless the expectation is that everyone is going to start operating out of monorepos

i've settled on all of this context attached to issues in a project management system and referenced from commits

it works just fine - its not like your agent cannot read your issue tracker

This seems like a great way to facilitate data gathering for improving LLMs coding performance.

If previously you needed to take action 1, 2, 3 to go from state A to B, all you saw was the change from A, B. Now you see intermediates 1, 2, 3 and can train the models to skip straight to B with the added context of the intermediate states.

Just a stream of thoughts: if git commits were a list of sequential primitive changes instead of diff snapshots, conflict resolution would be trivial in most cases.

Not without cons of course: commit byte size, public WIP work and leaked secrets/unwanted edits.

I swear a lot in my chats with Claude..

Well shoot, they beat me to the punch. I’d been circling around something like this, just not collaborative and obviously more thought out than my random experiments. Minus the collab portions I’m interested to see how it compares to jujutsu

Music is the silence between notes

I'm glad to see this feature and looking forward to see how it evolves.

Many of the product decisions that Zed's made caused me to switch to Zed for my daily driver IDE (previously JetBrains). The recent AI agent threads and improvements around diffs really solidified the move.

I hate software tools now. I really do. A hammer would never ask you to think about it constantly. If you think about your hammer it’s because something is wrong with it.

Just what we need, a new kind of version control %]

The work product is not the work.

> Before agents, it was easier to believe that the ceremony of trading comments on snapshots was an effective way to collaborate on software,

I’m highly skeptical of this claim. For any complicated feature, there’s always a design doc (or an RFC, or a wireframe) and that’s what people used for discussion. Discussion in a PR are mostly about whether to accept the code, reject the feature, or provide feedback about alternate implementations. It’s not for pair programming or directing design.

Collaborating together in a research lab (brainstorm session) is not the same as asking feedback for a journal article (PR). What is described in the article is pair programming with extra steps.

I'll probably get more hate for saying this but fine: I use Zed 50% of the time (the other 50% dedicated to vim) for two reasons:

1. It is fast and snappy. Nothing comes even close besides vim (and I don't mind going full time to it if I have to)

2. The ability to completely shut off and block any slop machine features from interfering with my workflow or leak code back to sloppenai, sloppus or any other self-installed-worst-security-practice-backdoor garbage.

Having said that, I hope they don't remove that ability in the future and enforce the "slop is so good man, you should try it" philosophy.

I really like Zed. It's customisable enough for me to make it look how I want, it's faster than every other editor I've tried (scrolling is silk, zero lag anywhere), it has enough features that I don't need an IDE (debugger, refactoring tools), and it generally gets out of my way.

I also like the AI tools, the inline assistant is good and the agent is also pretty nice and well integrated into the editor without it being the focus point. I'm not against using AI but I certainly don't use it as much as a lot of people do.

That being said, I really dislike this recent push towards becoming more like a cursor wannabe. They have a new (for now) opt-in default layout that almost hides the editor panel in favour of the agent threads and agent panels. And now this. I don't want to switch editors, but if they keep pushing a different workflow from what I use it might send me back to Jetbrains...

With LLMs now being responsible for the physical typing of code and mundane plumbing tasks, this is a wise direction to go into

Our human ability is not defined by our _absolute_ output, but, by the quality of the _delta_ applied to an engineering artefact

Great engineers obsess over every keystroke

With LLMs, a much smaller number of keystrokes can create a much larger and more positively impactful delta

Every delta to the codebase can tell us some informational property about the behaviour of the system and storing that information WILL prove to be useful in the future