Funnily enough, my first impression for this project was to use it for non-code and planning first.

I agree, I don't think people are going to remotely pair-prog with this when it's existed in the past and most work on their own and let their pull requests do the talking.

But I say non-code and planning because I've definitely strategized with AI before and have scrapped a good chunk of it because I overlooked details that my team shared. Being able to get that on an active session with context shared across all members as it's debated sounds good and would've reduced turnaround time.

I remember the Opencode folks mention about gangprompting before and I guess this is one take of it, besides adding an Opencode bot on Slack and hoping that's competent enough for the work that needs doing. I've never tried it myself, so I'm not gonna criticize it, but I'm sure it's an idea people want to see if it's effective.

Ever try editing like, a Google Doc, while multiple people are in it? It's not fun. I can't imagine how that would go when people could be changing functions I'm referencing, etc. Isn't this was version control is for?

I don’t think the emphasis here is on real time multiplayer, but instead on async multiplayer. The way it’s described is about an evolving code base over time. Everyone sees the conversations, comments and decisions that lead to the code in screen. Individuals directly interact with the code via agents. Other devs see all those deltas and can add to the discussion.

Pair programming is a great way to do knowledge sharing and collaborate on tricky problems. Now, I don't really want a multiplayer editor, but I'll highly contest that coding is solely a solo activity.

Sometimes I feel like people online hate all their coworkers. Thankfully, such people have not been highly represented amonst those I've worked with.

> I have no desire to do multi-player development in my editor. Never have had any such desire. Coding is a single-player game and I can't think of a single thing that would be improved by having someone else in the same editor.

I've definitely used the live sharing session with VS Code in the past to help coworkers debug or give them some suggestions for how to structure things (usually giving Rust pointers to people newer to the language). I haven't done it in a while though, probably because nowadays people will just ask their agent rather than me.

Looking at it from the perspective of StarCraft, doing a Blood Bath 1v1 against a bot its pretty straightforward. Adding another player to make it 2v1 has the potential to make it a lot easier, but there are moments where the bot could take out one of the players or at least pressure them enough to tax resources. Obviously, this all depends on the skill level of all the players/bots and their strategies.

Instead of the two players having their own base, they are running a shared base against a single bot. This makes it challenging as now the players are forced to communicate, or one can sandbag, but overall adds a bit of complexity. Though a shared base should allow one player to manage one aspect of the game while the other player manages the other aspect; such as building units and the base, while the other player navigates or harasses the bot.

It is possible to logically work together to get a better outcome, but the tools we have currently don't support that. I find this multiplayer approach intriguing as with the right formula could unlock a nice super power. As I would imagine having twice the mental bandwidth available such that more things are noticed or caught or imagined...

Yeah, I think there's a lot of fans of "pair programming", including the zed people...

Multiplayer agent thingy is a VC keyword these days.

It's not a full IDE but you can see the files and docs mentioned and created in the Delta chats. I often will pop open the right tab in Delta to check that.

My assumption is that people who want multi-user code editors are the same people who are forced to work in a place that requires heavy pair programming.

I could see it being useful if you're helping someone debug something, but chances are it's easier just to screenshare.

Also here, it's a really cool conversation https://syntax.fm/show/1029/the-workflow-of-the-future-with-...

I think the point is to incorporate it in the end in to Zed. Becoming the new thread panel or something. But it's just not something that is easy to fiddle with inside a working editor that many of us rely on to make some money.

I expected a release today because they didn't want to date the podcast episode recording date lmao

Because nobody's actually implemented it properly. VSCode's live share came close but was buggy and unusable.

It's a code editor. Are you using it in some other way?

What makes it better than Conductor?

Sure, they're backed by a VC company that is all in on LLM hysteria so everything they backed will have to back that narrative so they can dump their wares for a profit.

It will cause the community to fail because VC dev tooling is unsustainable as the community needs will never take priority over what their VC benefactors want. So if you want the slop that helps you pump out slop they got you covered.

It sounds counter intuitive but you have to remember nearly every business of the planet operates as a centrally planned economy with either a monarch at the helm or an aristocracy. These are some of the least efficient ways to collaborate as humans, at least if history is anything to go by.

I suggest you focus on real open source solutions like neovim, emacs, or helix.

There's Gram, a fork of Zed without the AI: https://gram-editor.com/

What principles do you feel they abandoned?

Sublime

I use AI explainers a lot in my own projects and have skills that give outputs I like. I'll even pipe the output into NotebookLM to make a video sometimes. This is actually a decent way to grok complex subsystems (YMMV).

What I don't care for is the pretty-yet-verbose HTML outputs that I see from some teams. They can be way too long and it's often the case that the engineer who made it didn't read the whole thing.

Delta.dev is the same Rust application as Delta, just compiled to WebAssembly and rendered through WebGL. So it's already web accessible, and can naturally extend to mobile platforms as well!

(i worked on this)

Would be nice if Zed announced anything related to what Zed actually is: a code editor.

This thing is fairly new in software years and has already stagnated. Bugs, glitches and rough edges all around. Almost feels like abandonware.

I first heard of Zed back when it was “the code editor that respected your choices”, you could turn off AI entirely with a single switch and all that… guess it was too much of a pipe dream to hope it would continue down that road.

This thing is now just a white-label version of Visual Code. Nothing more. Nothing less. Same software, different case.

What a shame.

neovim

I think the value come from monitoring agents work by multiple team. like architect, developers and security team together, so you dont need to have the back and forth.

I wonder if a productive avenue might be "doing aspect-oriented programming in reverse": asking the LLM not to "summarize" the code per se, but rather to "clarify" it by transforming it into what a programming blog post would call a "toy example" of what the code is doing, by stripping out all the (non-semantic) error-handling, logging, metrics incrementing, etc — all the things that you might treat as their own "aspects" under AOP.

I've found that I don't mind getting a lot of text back from an LLM, when I was the one who prompted it. I can easily enough let my eyes flit around in the text and figure out what I need to, and I expect that putting all that text in the context window will help with the rest of the conversation.

It's when that text gets copied and pasted into a blog, or a PR, etc. that it really galls.

I don't like the default explanations. But I prompt for small code snippets with explanations of a problem and the solution. This is in the context of extending features, fixing bugs, reviewing new code etc. I still skim the code, but it's nice to have a somewhat thoughtful overview of the key points like database schema, API spec, algorithm or abstraction. It makes it easier to skim a large diff without feeling lost. It also quite often catches some weird choices that might slip through it not carefully reasoning about the code. For me it is hard to understand code I didn't write myself so I have landed on this workflow.

The "language model" aspect shows IMO, at least for someone who grew up with the material of 90s and 2000s where we describe things more in mechanical, engineering terms. When gpt4 landed it was somehow amazing to see the output, but yeah nowadays I keep skimming through the explanation. It's like an intermediate dev who has nothing else to do but create long sentences to describe what could be simpler.

I wish LLM summary of code was put aside the actual code, like the Jasmine documentation[0].

[0]: https://jasmine.github.io/tutorials/your_first_suite

> On (2), I do find myself consuming agents' gigantic text responses, writing 8-bullet-point responses to guide them, then iterating that way. It's pretty exhausting. I could see inline comments providing much better ergonomics.

For your 2 plannotator [1] has a nice way to annotate agent messages or documents and its integrated into the agent chat (codex app also adopted the pattern)

[1] https://github.com/backnotprop/plannotator

It also seemed mostly AI, which made me think, okay, I'll copy and paste this and have a model summarize it for me, but it seemed, I don't know, low effort, not interesting. I didn't even bother.

There seems to be this push towards more agents, more better. Me no write code, me just yell at box. But recently I've actually gone the other way. I stopped using the frontier models and just started using cursor auto.

Mostly because it's just insanely fast, like 20 times faster than the frontier stuff. And it really isn't that bad. If it screws up, it's fine, I can fix it quickly. If the frontier models screw up, I just burned two hours.

The last thing I want to do is burn $20,000 worth of tokens overnight, to realize they made a complete mess.

Yeah it just feels like the whole post is unimportant.

Precision feedback for CLI-based coding agents is terrible. We built and open sourced PlanBridge (https://plan.contextbridge.ai) to fix this. It is a CLI that lets your coding agent open a local browser with a rendered plan/spec (or just the last agent message) so you can select and comment directly on the text and iterate with precision.

Directly annotating parts of the convo is the feature that really unlocked Delta for me (have been testing the alpha). So much easier than trying to explain to the agent what I'm responding to in their giant text blob.

Presumably it’s easier to iterate upon and judge solely on its own merits when it’s a standalone application. Maybe this isn’t optimized for user comfort, but for efficient product exploration (for now).

AI summaries are great for learning which parts of the codebase are load bearing.

There is a reason Caveman (https://github.com/JuliusBrussee/caveman) is as popular as it is

I'm a bit confused by your use of 'pithy, but at least its terse'. Don't pithy and terse mostly mean similar things? Here it seems like you're contrasting them. Not trying to be pedantic, apologies if it comes off that way.

Right, the value is not so clear of having multiple people wade through lengthy LLM responses. Part of the value that a human in the loop adds is figuring out what's correct and important in the response and passing on a more polished result.

The Codex desktop app lets you highlight anything in the transcript and add it to the chat as an annotation.

It's a solid experience so far (have been testing the alpha). Being able to work across model providers in parallel is my preference, rather than being stuck in Codex desktop, for example.

To be fair: a year ago the editor was in the center and the AI chat was in the sidebar-- Cursor.

Here they've moved the AI chat to the center and code editor has been pushed to the side.

The product is not an IDE, it is exactly the agent-native experience you're saying is required for current gen models.

The Codex App has inline comments on output/diffs and it has made such a difference for iterating. Like Delta I expect to see this adopted everywhere.

The interesting bit is this type of UI doesn't fit very well in any of the existing terminal TUIs, I have only seen it enabled working well in GUIs.

> Do I have to read the whole transcript just to understand what's going on?

No but you will want all of the transcripts anyway.

> AI will summarize it for me?

Not exactly. You will have some question later that you would never have entertained during your thousands of conversations about code.

You’ll ask your AI something fairly abstract but it will be deep in the context of some other idea.

And the AI will find among all your conversations those turns that are relevant to solving your problem or explaining why.

I know this is the case because I’ve built this and use it every day.

Here are some examples:

   1. Resume unfinished work → "where did we leave off on that?"
   2. Recover the intent/scope → "what was the actual goal of this whole effort?"
   3. Verify it got done → "did we ever finish that, and which session proves it?"
   4. Recall a fix → "how did we fix this the last time it broke?"

I shared these and more in my post in the August “what are you working on?” thread. [0]

You would be amazed how good the agent can be at assembling queries against a corpus of transcripts and assembling the results.

My product is called Contextify: https://contextify.sh

[0] https://news.ycombinator.com/item?id=49236853

If one builds something with an agent, the process itself is largely opaque. Preserving the transcript shows the reasoning of the agent and the decision process of the builder. This way everyone's on the same page instead of re-prompting same CLAUDE.md but with different results, and/or going through similar work over and over again.

I am willing to bet there’s a strong correlation between people who post/comment on Internet forums and anti-social behavior.

It's less hating coworkers and more enjoying the perfect logic that comes from interacting with a cpu versus the fuzzy nature of human moods etc. It's likely why a lot of people (myself included) got into coding.

There’s tons of reasons

- antisocial people

- larpers and students and shit who don’t even have a job where they write code but comment like they do

- people who don’t do shit for 3/4 of the day and don’t want to be accountable for that

- people who work with too many idiots

Probably lots of other reasons. Personally I think it’s fun and useful, but I wouldn’t want to do it exclusively. Maybe scheduled hours a couple times a week. LLM aided development can be very similar experience.

Also a great teaching tool.

Big part of my job currently is taking slop level Pinocchio prototypes and turning them into a real boy. I’ve decided that I’d much rather have all of the conversations these people have had with Claude when creating the project than the final code artifacts. Hopefully we get more tooling in that direction.

I consulted on an internal project where the leads literally made one dev control the keyboard and another dev control the mouse! It was the most ridiculous thing I ever saw. I fought for those poor kids, the leads were eventually fired or quit.

Yeah, YC also has their own "multiplayer agent", qm (https://github.com/yc-software/qm), though it doesn't seem to be focused on code, which makes a little more sense.

Awesome! I'll for sure look into that.

Those HTML reports are almost always filled with fluff.

As someone who likes a nicely designed report document, slapping a coat of paint on slop output isn’t helpful

Ah, now I hate all my coworkers because I don't want to share a keyboard. Incredible insight.

pair programming is when two people collaborate on engineering decisions while one of them codes.

during those cases, i've just asked them to give me control over zoom and it's worked fine.

I've never desired to have two people working on the same file at the same time during a debugging/teaching session.

You just reminded me that 90s StarCraft did have a mode where 2 players would command a single “team”. Basically a single “player” with multiple cursors. It was rad! Haven’t seen the concept duplicated.

I would focus on the economy and my brother would do the military and fight the bots.

I remember the fad. I was around for the Extreme Programming era. But, I've never worked anywhere that pair programming was the norm, nor have I known any developers that wanted to pair program, in the general case.

My personal experience is, of course, not representative of an entire industry, but I just have a hard time imagining it being a common thing. I like working with other people and helping juniors sort out their problems, but I'd quit my job if I had to take turns writing code while someone else watched and just sitting and watching someone else writing code. Both of those things seem horrible, to me.

I like using my mouse

Just because they started out as a code editor doesn't mean it has to stay that way. I was looking forward to a more modern Sublime Text in Zed but I also know that nobody is going to make money off a simple code editor.

> This thing is now just a white-label version of Visual Code.

That's a wild hot take, and pretty ignorant to the people working on that for years.

I thought Caveman was debunked in the token saving argument? In real sessions it doesn’t really save much longterm and made sessions more forgetful/take longer.

One thing worth flagging: summaries can provide context that is important, but you should always remember to thoroughly comb through the information in case there are caveats in the text that may act as a heads up, which is important.

Paseo and other agent harnesses can let you work across model providers as well.

You can also add comments directly in the diff view and they submit in the next message you send.

Zed already has a “agentic layout” for a while. It shifts the ai and threads to be more prominent and moves code + sidebar to the right

I guess my main point is that the additional features on top of DeltaDB don't seem terribly important to me anymore, compared to the alternatives.

the problem w/ this is that if people actually need their logs saved...99% is to finetune custom models on their codebase later...this is a whole pipe, u neeed to refine and prune the data into proper format for reinforcement learning i think...they will never us a mac app for this, they will use same agent and have custom scripts for this. for programming ur context is the codebase..not the logs, the bot searching through all chat log is wasted tokens when they can read context from codebase directly, and if not then they can search diff....there are edge case maybe like oops i accidentally deleted this code its only in chat logs.....you simply tell to go find log and extract data....so you cant make a product on this sorry.

Thanks for pointing that out. I tried the Codex App before but didn't see that.

I want to like the app, but I'm not sure if it actually fits well to my use case. With my current setup I need to fully quit and restart it if I want to work on a different project (to get it to use a different API key) and I cannot work in two threads belonging to different projects at the same time.

Also I generally prefer to handle sandbox the entire agent and disable its internal safeguards. Beside any doubts regarding the quality of the relevant sandbox implementations, I have just gotten my projects to work better this way.

I think he’s saying that’s it’s dense and _too_ full of meaning. So, while terse, it can also hide extra meaning in its density.

"Bob can be blunt but at least he's honest." Words can have positive or negative connotations for the same notion.

For me it's probably time to learn to use vim or something similar. I'm the only one that likes coding manually, without all this AI shit? I'm faster writing code myself than trying to explain to artificial stupidity what I intend to do and correct its output. And if I write it myself the code just works, if it's written by the AI it has a ton of bugs. I don't see any value in AI generated code that is not mere code for doing experiments that you don't care about.

The obvious next step is to remove the code editor entirely.

I understand the point, but shouldn't the code be documented and well structured so that the intent is clear without looking at the discussion around changes?

I'm working on a legacy system right now - I'd commit several felonies just to have well documented code, I don't really care about all the conversations that the original team had to decide what they eventually did.

Maybe I'm just too old and don't get it.

Yea that never made sense to me. I think and solve problems as I code, and having someone yapping while I'm trying to do that is a great way to disrupt my thinking process.

If you're not sitting in a group of 5 watching one guy code, then you're not a team player.

Even if you're not both typing at once, being able to trade off quickly without having to manually pass the ownership back and forth has had value for me in the past.

Are you sure you aren't off by 20 years and referring to "Archon Mode" introduced to Starcraft 2 in 2015?

https://news.blizzard.com/en-us/article/19940901/teaming-up-...

I love pairing. It always results it better outcomes than not pairing and I've been saddened by the slow decay of the term to now refer to like "talk to me a bit until I'm unstuck" instead of "both work together and get it done"

I worked at Pivotal Labs, it was an amazing experience to be in an environment where everyone was onboard with a very well defined methodology. Certainly not for everyone, but everyone who was there had the same mentality. A bit like you'd expect from a cult or the military.

Emacs then? :)

Gnomic, then (on my mind because I saw it used yesterday, thanks flir).

That's insightful! In a negative way.

Hey me too. This is my morning Zen moment refactoring and cleaning some code before I go back to the agent to earn money. One of the only things that helps me to relax is to do some manual coding...

There is never a bad time to learn vim! Not only is it a super useful skill if you end up having to edit a file on a server (and you don't want to deal with nano), it also makes coding fun.

It seems reasonable that a professional-tier of software developers will have tools distinct from everyone else. No matter what the percentage looks like, experts will still be a thing that needs different things.

I happened to "pair program" for the first time in years today! My coworker asked me to come over and help him with a problem.

'course we only did it for like 5 min to get him over the hump.

I think that's the only use case. It sucks having someone hover over you otherwise.

surely you could imagine that being able to sit in on a meeting that was had when they were designing the system would be useful for you?

theres a lot of context and decision making that is useful but not documented in the code. The code tells you how the system works, not how its supposed to work.

> That's a wild hot take, and pretty ignorant to the people working on that for years.

Hot take or not, it’s accurate. There’s little to nothing that differentiates Zed from VSCode now.

Can you elaborate? Why wouldn't you just check in your code when you're done your bit instead of working on the same commit together?

set mouse=a

This sounds like ‘pair debugging’ which I’ve found to work pretty well. ‘Pair development’ isn’t something I’ve ever really found helpful, though.

This is just the classic rehash of are comments in code an anti-pattern.

I tend to agree that at a certain point if you need to constantly think "gee, I wish I was in the meeting when they came up with this" the code you are looking at might just suck.

In such contexts it is also often the case that being in the meeting may not have helped. As they say, garbage in, garbage out.

neovim is ugly

Sometimes it is useful to simply know something was brought up, but then someone had a sneezing fit and everyone lost track of the thread and the important edge case under discussion just fizzled.

A similar thing happens in agentic conversations, where a model may point out something but it is not recognized as important by the operator.

A few directives later and the model is being pushed another direction.

It can be very useful to have perfect recall of moments like these.