Maybe an approach for interactive code reviews with distributed teams.

Also see: https://subethaedit.net/

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 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.

Multiplayer agent thingy is a VC keyword these days.

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

I don't understand the fixation the industry has on multi-player development either. Zed isn't the first. It's been 10 or 15 years since I started seeing multi-player development (sometimes called peer programming in an earlier iteration) being championed in various ways. VS, Intellij, Eclipse, and vscode had plugins for it and all of them are from the 2015-2018 time. One can even say that the Google Wave demo from 2007 was one of the earliest demonstrations for this concept.

I even worked on a team where one engineer loved the idea and championed doing it as early as 2013. Most of these IDE extensions didn't exist back then. He ended up picking a buddy, and they moved to the same office, hooked 2 keyboards and 2 mice into the same PC and spend literally the entire day alternating who's writing code in the same IDE.

I think the concept was supposed to be about helping developers share their skills. Every developer has an experience of looking over somebody's shoulder and having an "oh shit, I didn't realize there is a shortcut/tool/command for that" moment. And the idea with multi-player programming is to get you to see that and learn from it more. But. It. Doesn't. Work.

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.

I feel I’ve seen the multiplayer thing being pushed ten years ago or so, guess it’s time for another round. It’s one of those things that makes for cool product videos but I’ve never met anyone who actually uses it or has expressed any desire for the feature.

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.

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

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.

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.

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

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.

We need a new specification language for summaries. I think just a (pseudo?-)programming language’s API (modules, interfaces, method signatures), but more concise and descriptive than Java, maybe Haskell or OCaml minus quirks (…the academics were this close to an ideal syntax, maybe they should’ve gave up those languages’ LR parsers…)

Your AI summary is raw output, like uncooked mince meat.

Ask for a rewriting pass! Get it to edit for word count, remove redundancies, remove run-on sentences, and change sentence structure to use active voice.

You wouldn't ship your first draft - why let AI do it?

Ask for a walkthrough of the highlights (with '...' omissions so that the most important parts are quickly visible) instead of a verbal summary.

You're absolutely right!

I hate fighting with the AI to get a good summary. Reading the good summary is great. Getting to it is the challenge.

First attempt: mountains of meta conversation and not answering the original question.

Second attempt: shorter and more concise, cuts out some of the nonsense, but terribly written.

Third attempt: goes off the rails, misunderstands what you are asking and tries pushing the work onto you.

Fourth attempt: finally something that's concise, reasonably well written, to the point and passable.

Yes this is why I ask the agent to summarize the code as a comic of a lizard explaining it to a cat.

> 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

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.

Yeah it just feels like the whole post is unimportant.

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.

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.

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.

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.

> 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?"

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.

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).

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.

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.

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

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

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)

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.

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.

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?

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

Sublime

What principles do you feel they abandoned?

neovim