My wish is that Zed gets the core working correctly 100% of the time before moving on to expanding feature sets. For now I'm back in NeoVIM because it always works the first time....
https://github.com/zed-industries/zed/issues/38109
Hopefully soon I can give it another shot at full time usage.
“Can I tell you about our lord and saviour Nix?”
Kidding, but seriously though I’ve found having to work in a container to be a bit clumsy, even with good tooling around it. As you said it’s 2025, and there are other ways to have reproducible toolchains that don’t pollute the rest of your system environment Nix or otherwise.
The "just use Nix" people are just like the "write it in Rust" brigade.
And the things both groups promote share exactly the same problem ...
A stupidly enormous learning curve.
That's why your average person prefers to just the job done in a container vs Nix, or in Go vs Rust.
I'm sure Nix is awesome, just like I'm sure Rust is awesome. But honestly, I've got enough going on in my brain at $work and $home without having to wrangle some obscure config syntax (Nix) or obscure low-level language complexities (e.g. Rust's infamous borrow-checker).
Every time I go back and look at Rust or Nix my brain is just like .... no, thanks.
Nix similarly forced issues to be reasoned with upfront.
THIS !
Go's well maintained stdlib just lets me get on with it.
With Rust meanwhile, I have to decide which of thousands of third-party Rust crates is sufficiently en-vogue and well maintained.
Most of my coding work is backend stuff that calls a lot of HTTP APIs, parses a lot of JSON and does a lot of crypto. All that is ready-to-go "out of the box" with Go stdlib and on top of that is faster to get to production in Go than in Rust.
I don't need or want Rust's complexity. As I said I have enough going on at $work...
But irrelevant in this case. I dev on macOS. I’m not aware of any other options.
> It’s not any different
It's very different. With docker on Mac you're running a VM which runs a wrapped up complete system that runs your app.
With selinux/sandbox-exec you run just your app and can skip the extra packaging needed for docker and mounts. (And get the extra performance)
If you're happy with firejail, make sure you use whitelists only and you'll be 90% there with what's possible to achieve.
With the continuous improvement in CLI tools and people’s experience with them, it feels like doing a live review or edit-by-edit approvals all feel like a drag. I personally have come to avoid using the IDE/Editor. I just kick up Claude code - plan mode, auto-accept edits. Once the session is done, switch to the editor and make necessary adjustments. I suspect people with Max subscription and “dangerously-skip-permissions” …etc won’t even care if an editor has AI integration or not.
But that can be done easily enough with an MCP extension for your editor/IDE of choice
I still use Claude Code in cli, as a WebStorm user.
I've noticed that not only does it sync but it even will recognize if I rename the folder a workspace is in.
But then, I've run into a couple of strange issues that tell me there is more polish needed:
- Sometimes upon using LSP refactor, it seems like if a bunch of files get renamed, the open buffers will get screwed up somehow. Like, I'll hit save and it will write to the old filename! It's not actually a huge problem, as I can close the buffers, delete whatever excess files I accidentally create, and re-open them without error, but it is confusing as hell.
- I have indeed had issues with the file view not always updating when files are added externally, however it is not constantly. I usually just reload workspace when this happens. It is a minor frustration, but I had many minor recurring frustrations with both VS Code and Neovim before too, so I don't consider it a deal breaker.
have a big docs or log,data file where you don't care for the rest of the line ? well too bad better have a spare editor.
this feel to me like it should should be a number #1 priority. "an editor need to nail the editing part".
https://github.com/zed-industries/zed/discussions/26344
on the positive side I do like that you can in-place edit the result of global search.
Not silly at all. User experience is important. If you're going to spend as much time in a tool as most programmers do in their editors, it should look and feel nice.
No settings to adjust?
https://github.com/zed-industries/zed/issues/7992#issuecomme...
This is how Zed looks like on my computer too. VSCode manages to render things crisply while Zed is a blurry mess.
It's like they're rendering a high resolution font at low resolution using the simplest possible algorithm without lining it up with the pixel grid. It's very fuzzy. Characters have this weird sort of additive color intensity where strokes intersect that reminds me of Geometry Wars. It's broken.
They are working on it; the Windows build has decent rendering, and apparently the Linux version substantially improved recently. But they haven't gotten to macOS quite yet. I've been checking in on Zed every few weeks since it went public waiting for a fix.
(Though there must be some cutoff point past which the pixel size becomes irrelevant. I certainly don't mind reading stuff on the iPad.)
Personally, I never registered that as a problem, but I can see the delta in screenshots between versions.
Also buggy git support, I selected a few things but it committed everything and made me think I lost it all.
But I love Zed when it works. Literally 5h more M4 battery life vs Cursor.
Where as with Zed it'll just keep showing the old content and in fact closing and opening file wont even change what it shows in Zed. It's really really annoying. I have to exit zed and open it again. This means if you are working with AI agents you end up having to do this often.
I use `"autosave": "on_focus_change"` which may be keeping my buffer in sync with the file contents as I switch between terminal and zed.
Don't bring the attention economy to my cave of solitude, it's where I go to escape all that noise
A lot of my IDE choices are about extensibility and flexibility more than perfection for my preferred coding approach. After all, until I only work for myself I need to be ready to accommodate the needs of others as part of my job.
I find Zed's feature choices to be really poor, and then I probably made a poor association based on his talking about zed
A monnumentous yak shave.
I've never used or cared for multiplayer in VSCode or JetBrains. It's silly.
I've never been the pair programmer type. The only time I've needed to share an IDE is during a SEV or ridiculously complicated systems bug, and that's 1% of the time.
1. Until this is possible without lock-in to a specific IDE, it's going to be heavily gated by adoption and network effect.
2. What are you going to do about communication with non-devs who don't use any IDE? Do I now have multiple chat tools I need to give attention to?
3. Bringing the attention economy to our primary work tool is probably a bad idea in the long run, given the evidence we have more broadly about the impact of the attention economy
4. They are also proposing a new version control database, which makes adoption and interoperability an even harder task. https://zed.dev/blog/sequoia-backs-zed#introducing-deltadb-o...
5. We are in an AI hype cycle, which comes with a lot of experiments and baggage. We're seeing both fandom and rational pushback against this experiment (and others)
Self hosting will be a vital feature for users and enterprises though, we’re planning on revisiting it once we have a few more features settled :D
I'm really rooting for you guys, and your direction and quality is exciting to see.
https://github.com/delta-db/deltadb?tab=readme-ov-file#-upda...
Here's our overall pitch: https://zed.dev/blog/sequoia-backs-zed#introducing-deltadb-o...
Also the name, I thought it was a database with CRDTs due to the "DB" at the end of DeltaDB, but it's a version control system, I thought that was somewhat misleading, any reason why it's named so?
This doesn't fill me with confidence.
I personally worry it's not interoperable enough.
C'est pas parce qu'ils sont nombreux à avoir tort qu'ils ont raison!
I'm happy that others can type in each others' space, but this post reveals a tension here. They are building a tool for building the tool, and their own team. I think that's cool, but at a 2-3 person shop heavy polyglotted across 4 OSes and 5+ programming languages, this is not what I really need.
What I'm looking for is a snappy tool (check) that lets me explore, understand, modify code at a next level (marginal). And I want it to not only be snappy by virtue of execution efficiency, but cognitive load. I want the less-is-more experience. I don't need it to do Swift, Kotlin, or Python, because there are bespoke IDEs for each of those that focus on the environments where I deploy them best. What I mostly want from Zed is the ability to see the outline panel at the same time as the directory panel, and to separate the search outline from the file structure outline. I spent too much time toggling views in Zed.
You can do this now by moving one of them to the right dock (right-click the toggle-button)
Yes
- Do you want to split a dock vertically?
- Do you want to open the panels inside an editor split?
- Do you want to detach the panels as separate windows? (https://github.com/zed-industries/zed/issues/17618)
I work with IDEs and low-code/no-code tools, VSCode is kind of unavoidable in some scenarios as it has become the only programmers editor that some companies bother to provide tooling support for their SDKs, and that is it.
For bettr or worse, everyone and their dog that used Eclipse forks for their SDKs, now is doing VSCode forks.
For historical UNIX purposes vi and Emacs, and then any editor will do when changing some bunch of configuration files, in case nothing else is installed.
In no project I would be able to make Zed our office, that is what stuff like Monday, Jira, Confluene, Trello, Workfront, happens to be.
This is not necessarily to endorse Zed; I’m ecstatically happy with my current text editor. However, “we peaked 25-30 years ago” is just not true. Things have gotten better and they continue to do so.
I could also see it as a potential productivity aid. Person 1 sees Person 2 is writing something and they don't want to be seen as idle, so they start working as well. This might sound oppressive but a lot of people who struggle with ADHD/procrastination/akrasia actually receive great benefit from that structure. Similar to that startup that forces you to code while screensharing with a stranger in order to push you to work, or people who code in cafes/libraries to be more productive.
As long as it's not an organization requiring it for senior engineers, I could see promise to it as an eventual common new paradigm.
This would be good for code-walks too though. Instead of having to share your screen and hope the video comes through well. Everyone can follow along in the comfort of their own editor.
it's probably subjective, but I find these collaboration features can be overused for this kind of thing.
If someone is walking me through something, I just want to see what they see so I can focus entirely on what they're saying and no part of me is distracted by having to follow along or seeing other code.
I know typically these collab modes have an auto follow feature, but it's not as simple as just read only video being streamed to you, there's loads more ways it can go wrong and add noise / distraction that provides no benefit.
I agree being able to see the pointer is important, since not everyone is good about moving the cursor around.
The experience was actually quite nice for two-three people but we always had the "ok let me type now" flow. Multiple changes happening at once sounds hyper distracting.
or at least that's what i've heard, no idea if they actually do it.
it is nice to see a crdt backed editor tool for markdown and code though. gdocs markdown support has been lacking for years.
Yeah, we used to do that back when I was in college. It's only for certain classes and most people usually kept their own notes too (or instead, why write twice). Or some classes ban laptops so you'd write on paper anyway.
When learning a new way of thinking or moving (i.e. martial arts) people often really benefit from high-bandwidth, low-latency, shared-viewport-onto-reality interactions. Watching someone's cursor move while they talk is one way to get a window into their problem-solving toolkit.
Let's lean into the chaos and see what it might give us. Imagine a production application deployed directly from a non-version-controlled directory. Anyone on the team can edit the files, at any time. Insane? Probably. The disadvantages are easy to see.
But the positives are really compelling: 1. make small, granular testable changes; 2. use feature toggles; 3. refactor intensely and concurrently; 4. always work on the latest code; 5. use in-code documentation instead of GitHub/etc workflows; 6. explore continuous, incremental, hot-swappable code deployment.
Doesn't thought of ditching all the wasted motion and ceremony around logging async work and just coding sound glorious? I'm actually not a "move fast and break things person" usually. But the idea of moving so fast that broken things will only stay broken for a tiny fraction of the time is pretty compelling. There is also an intensity that comes from real-time interactions where a team needs to reach consensus quickly.
Feature Toggles: https://martinfowler.com/articles/feature-toggles.html
BEAM (Erlang, Elixir) provides hot-swappable code and lots more
It's probably not an issue the Zed team will experience as they're all naturally using their own editor. Hopefully it's on their radar though.
Network effects are probably a strength for a company, not a drawback (which it is for the user of course). Even VSCode has some notion of network effects, such as their proprietary extension store.
However, I just tried it myself and was really shocked to see other people in my sidebar after I clicked on the “collaboration” stuff. I expected to be dropped into my own collaboration environment built around my own channels, like a fresh private Slack instance, but instead I saw the built-in Zed channels and as I clicked around, it looked/sounded like I was joining voice channels. It was as if I’d accidentally joined someone else’s Discord. It was so mentally jarring that I got afraid I was on a live mic or would accidentally be live-sharing stuff with strangers.
This feels like an attempt at deflecting blame. VSCode is another Electron application that ended up having better performance than Atom. There's another Electron adjacent application that has good performance, the one you're probably using right now to read this page.
Depending on page content of course
VSCode can pretend to be fast in my desktop, and I would not care because desktops today are computing monsters that rival supercomputers of the past, but Sublime Text is still much faster at any text editing task.
Atom was kinda like emacs. Extensions could do almost anything. VS Code has a limited api that extensions can use
Web technologies are an unrivaled technological marvel for what they are, but it is disingenuous to imply they represent anything near the peak of what we are capable of in the context of performance.
In my experience VSCode is plenty fast. Use it with no extensions and you will have zero problems with performance (though memory use isn't great). The real problems come when you have extensions, especially because it's often impossible to attribute performance issues to them because they can often do a lot of work all in the same "extension host" process.
Memory use is a part of performance, though, so I definitely would say VS Code has serious performance issues. It's why I no longer use it, in fact. It's inexcusable for something to eat as much RAM as VS Code does.
The multi-user editing is kind of cool... there's an ANSI art tool (PabloDraw) that you can run a host session so multiple artists can create text art, and I thought back when I first saw it, that it might be cool to be able for multiple editors to work on a project. I've used some of the collab stuff with VS Code, but haven't done enough to even begin to compare.
Not to mention that in a lot of workplaces, self-hosting or otherwise layers of bureaucracy stand in the way.
If you've been a developer long enough, you might recall the teletype package for Atom—both built by Zed's founders.
Appropriately working together on a truly collaborative tool, Martin Ott, Martin Pittenauer, Dominik Wagner, and Ulrich Bauer of Technische Universitat Munchen won the Best Mac OS X Student Project for Hydra 1.0.1, a Rendezvous-based text editor that enables multiple people to contribute to a shared document. (Adam and about ten other attendees at MacHack used Hydra to take notes during this year’s Hack Contest.)
https://en.wikipedia.org/wiki/SubEthaEdit
https://tidbits.com/2003/06/30/apple-announces-design-awards...
I'd say CRDTs are also a big change. CRDTs make live collaboration much more robust for all parties involved, and they only started to reach maturity in the mid-late 2010s
As time goes on it feels like much of the low hanging fruit opportunities in software is disappearing faster and faster. I'm also a fan of Zed and everything they're doing, but it's notable that shipping next-gen editor software takes a lot more developer effort now than it did in the 2000s.
The Graphic Editor workspace, in fact all the Adobe programs alternatives is quite open.
I remember using Paint Shop Pro, and it was bought and killed by Corel. I would prefer to keep using Paint Shop Pro, instead of Photoshop, because it was super fast and had all the features I used and wanted.
Ask people why they can't migrate to Linux, and half or more of the answers are: Adobe.
Yes I agree but so many things that might seem "done" (and in someways I think software/SaaS as an ecosystem is "done" compared to where we came from).
BUT - so many companies just bloat themselves and their products. I think the end of ZIRP is going to have an effect on that (more enshitification / rent seeking for sure) and I think there will be an opportunity to iterate and make copyware that doesn't take the higher development efforts.
We really need a winning electron alternative that is more resource friendly. That, IMO, will be a big game changer and I know there are lots of promising alternatives already.
Yes, the scope increase is vast, due to more languages, more tooling, more features, higher expectations, and more competition.
We started building zed in zed using it's collaboration in early 2021. Collaboration has always been part of it's DNA. Nearly everything at zed is written in pairs over collab.
I joined a Zed hackathon at RustConf 2024 where I built the "Open in split" functionality from the file fuzzy picker. A member of the engineering team who was floating around helping folks had us exclusively work through the included collaboration features. It was a great tour of the editor, and did not feel tacked on.
I dont honestly dont get the allure of pair programming. My pair programs are the unit tests which I run as often as I can and limit discussions to Gitlab/Slack. I have worked ag FAANGs and large companies and never once pair programmed anything.
I honestly cannot think of a single software or process problem that requires real time collab in the editor. Having said that it is a cool feature and I quite like Zed as an editor.
It's because the collab tool wants to have access to the code as it changes live. It could and should be done in an editor-agnostic daemon like LSP, but then you wouldn't have editor lock in. And that's why both Zed's collab and VSCode's LiveShare are builtin.
Anyway Zed has a very interesting idea to provide links to codebase places that remain stable even after the codebase changes. This is pretty cool, because so many discussions about code quickly become outdated
It's not like the editor prevents one from still using slack and other external tools, either. I guess I just see the value in in-editor integration to handle that stuff more smoothly, at least for those using the same editor.. I can see myself really appreciating the feature if there's a part of the codebase that consistently trips people up or is under active discussion.
But how do you monetize a programming language, a text editor, a build system, a terminal emulator, etc in 2025? The examples are deno, bun, mojo, nextjs, zed, earthly, warp, etc. all know they can’t monetize the actual tool. You monetize services that you build around the tool. Like a cloud/workers/deployment (basically compute), or a sharing service or an AI service, etc. once you have critical mass on your platform, you can find other easy services to offer. Like if Zed has a critical mass of users, maybe the offer “in editor chat”. A small startup with just 3 devs working together can replace slack with zed. Maybe they offer an uptime check service. Why not? Maybe a file sharing service. Maybe a small wiki service, etc. all things that have million other solutions. But if you have critical mass, someone will pay for those things.
Once they finish their collab platform they can make it standalone. The current version in Zed seems to be isolated very good.
Pair programming is Two People One Cursor. A critical aspect of it is you're both looking at the same lines of code and working on the same problem and following each other's thought processes.
CodeWithMe (and it seems Zed) is Same Codebase, Same Day. There's no shared focus. You edit stuff, I edit stuff, maybe there's overlap. But this isn't much different from doing separate git commits.
So far the only remote pairing tool I've found that works competently is pop.com.
In contrast how I like to work, with similar level people, is to work at the same feature in the same codebase at the same time. We either sit next to eachother, or have a remote call, where we continuously talk through what we want to achieve. Sometimes this results in one person writing ahead (code, docs, doesn’t matter) and the second sweeping behind it and cleaning it up. Two cursors, one source. IntelliJ even manages to keep authors correctly in git.
The other mechanism is where we work on different parts of the code base at the same time. Either main code and tests, or split across interfaces and implementations. Because this happens on the same machine the iterations are way faster as they are local and incremental.
This basically saves the whole dance of creating branches, pulling/pushing, the fixing typos etc.
I never used Zed collab, but isn't there an option to follow someone's cursor rather than having your own separate cursor? Zed even has an option to follow the cursor of an AI agent ffs.
I know that VSCode's Live Share allows you to follow the cursor of someone else. However Live Share is very buggy and will disconnect at times, so it's more like a cool demo than a product.
IMO if you only care about coding doing it in the editor is the best approach, you get zero latency and have all the context that you need (most of the times). But if you want to do more, like opening the browser for whatever reason, or teaching how to use a specific cli, etc, then taking control works better.
If you liked pop you might like gethopp.app, which is an OSS pair programming app (full disclosure I am the co-maintainer). Unfortunately because we have chosen tauri for the frontend we can only support macos and windows, but I am working on a solution for Linux too.
Is it just my vision, or are websites getting super low contrast these days, esp the text-heavy ones?
Could be your monitor as well.
I have more to input here but I forgot some of them, overall, I just want to get back to vscode which is much easier and battle tested. I think zed have a totally different perspectives on feature sets and stuff, that's good, so people could have another choice. Hope zed could do great and I will definitely come back one day.
PS: I don't think collab worth too much effort in an IDE, you have much better tooling out there and have better intergrations.
The screenshot below surprised me:
https://zed.dev/img/post/zed-is-our-office/this-week.webp
All the colorful avatars and the busy side/top panels feel out of character with the usual Zed aesthetics.
But Zed is an insanely fast text editor to open text files in. Just double click and it's on the screen. Love that. Maybe over time I'll do more in it.
I can't stand Nano. I find it impossible to use because my brain is strongly vim-bound.
I daily drive Zed for work across several languages and I love it. I use a lot of its features, like the git interface, agentic editing, etc. I might even consider paying for Pro in the future if I want unlimited edit predictions.
However, all of these complaints are fully justified. I think Zed is a massive undertaking, only one that a VC-backed company has the capital to do. iirc, it requires 70k lines of Rust just for the cloud part [1]. I cannot fathom the amount of fundamental infrastructure they have to get the editor functional at all. That doesn't excuse all of the papercuts in Zed though.
If I were Zed I would do the following:
1. stop all work on future features, like DeltaDB etc. They all seem extremely cool but they won't meaningfully contribute to increasing Zed adoption or fixing its issues.
2. remove all agentic editing features. if Zed tries to simultaneously become the world's best agentic editor and a good general-purpose text editor, it will fail at both. Keep around ACP so users can still use other agents, but remove all of Zed's built in agent stuff.
3. fix literally every papercut. Triage every single issue and go through every PR, even if it will take half a year to do so. People won't switch to Zed until it's perfect, and the existence of this many issues means it's not perfect enough.
4. make extensions actually good. Every programming language, library, etc. has it's own ecosystem, and many such ecosystems mainly rely on VSCode extensions for advanced features. Zed needs to be extremely extensible like VSCode is; obviously its architecture makes this slightly harder, as it's nontrivial, for example, for extensions to render their own GUI, but there are a lot of low(er)-hanging fruit for extensions that need to get solved. People will only switch to Zed if they can get a similar breadth of ecosystems.
Of course, this won't happen, and given that none of these will really make them money, Zed has no incentive to focus on these, especially given the amount of time they would need to do this. But I think that if Zed can't nail the core experience, it won't get anywhere.
[1] https://maxdeviant.com/posts/2025/head-in-the-zed-cloud/
1. big corporate shops / vc funded ones - many tens of programmers working on features (this is where zed collab features might be needed) 2. bespoke high productive small teams - less than 5 product programmers in a company e.g basecamp - these would be your bespoke law firms 3. the indies (injury lawyers) -> 1 - 3 programmers chunning out products at scale or eating of one product + maybe with help of A.I
for 2 & 3 - a lot of stuff being shilled is not needed. a legal pad + some notes that can be posted via a google doc is all that's needed. Jira isn't needed too
- On my Tablet, which is too slow for Jetbrains IDEs to run smoothly
- On certain projects I have which choke Jetbrains IDEs. (Due to macro use maybe?)
I'm also trying their GPUI library, but am in the early stages, so can't really comment on how it compares to EGUI.
I'll always remain someone plugged into vim because I need it sometimes when shelled over a terminal. Editing files over SSH can work with editor support, but is often less reliable or fast than jumping through whatever hoops I need to to get an SSH connection once and then doing everything from there.
Sadly my workflow of using `!` to get back to my terminal and things like `!make` or `!cargo build` is fucked in neovim. So I do a lot of ctrl-z and the a lot of killing stopped processes I forgot I suspended. I've complained about this in various threads and chats, but the developers aren't interested in letting us use the old vim `!` which is super lame.
I'm sorry... what?? I still use vim as I haven't found a reason to jump to neovim, but you're telling me external commands don't work properly? That's wild.
Another way of stating this: It's a general purpose portable computer; not specialized coding PC.
> Collaboration as it stands today is considered alpha, and for the time being, is free for all to use! Peruse the source code.
Zed and the current crop of AI editors (including VSC itself) are that toothbrush.
Of course, it would be awesome to have a faster and open source slack, and if I can take notes on the same style as my editor great. So I guess, it would be nice to be able to embed zed in another product.
I think this would be appealing for a company that it's core product is code, like zed, but I do wonder if other companies even need this functionality.
I'm just too hooked on that OpenVSX ecosystem.
I do wonder if we need a term for shoe-horned dogfooding though. Like sure, you can do this. You could do this in Figma! Or in Notion! Or in LEETCODE if you wanted to.
At least with Zed though, its plain text. If you find another way to collab realtime on plain text, you're not bound to 1 vendor.
While I do not work at Zed, I'm curious to hear more about this use case for my own company needs.
Code wise I guess you can could be working with any agency or contractors and you could collab on PR reviews? No idea to be honest.
was floored by the "explode all layers in the user interface and simulate a 3D camera rotating around them" graphic when i first saw it !
3D is always difficult to get right, but felt it had some really cute possibilities,
any way to open this up so devs can try things out?? < 3
What is this in reference to?
I think collaboration for people who eventually use the software will be more critical in the era of agentic coding. Project Management will change. We are not waiting for 2 weeks to build prototypes, it gets done in a hour. What does that mean for end users - do they prompt their changes and get access to new software? Who would double-check, would AI reviews be good enough, would AI agents collaborate along with humans in the loop?
There are so many questions not answered. If anyone is keen on having these talks, I would happy to share what I think. Here is what I am building: https://github.com/brainless/nocodo
I want to see a future where end users can prompt their needs, have collaborators in the company to help clear things up and in an hour the feature/issue is tackled and deployed.
When it comes to writing tool the trend has been strong that people want distraction free writing with no interruptions.
Seems like code editors are going the other way on speed.
I think Tuple is a better collab app, but far more expensive.
For instance, collaboration is a huge topic. You can have coding collaboration on the file, and that would be basic and appropriate, you can then replicate slack and you'll have chat rooms, which is entering creep territory, but it's natural! Then soon the chat room will need to link with issues and you can now have TODOs linked to some kanban board and we should be able to speak while we code on the same file! And this goes on and on.
It's exceedingly rare that the organization found hard courage to specifically avoid features that looks like easy pickings for the purpose of avoiding them.
Also Zed was announced as a closed source comercial tool.
> "Wish there was a windows laptop I could buy that is good"
What does it even mean? There are macs, there are chromebooks and there are just laptops. Wth is a Windows laptop? There's a good Linux laptop?
Just a nit :P
I run update and Collab requires you to sign in... which again, it is fine if you want it. I don't, so it can be dormant, icon is really tiny, doesn't take much space.
The feature of Zed that is most annoying yet essential is frequent updates. Pretty much daily when I switch to Zed window, I can expect update and restart, which messes up my window layout, so this is annoyance. Getting updates and knowing you guys are shipping good stuff is what is essential.
I think integrating terminal ai's is great move and useful. Sometimes I use it like that, often I use it in terminal (like the outside of the editor terminal) and switch to editor to review or update stuff. Same with git. I am old-fashioned.
Moreover, this would be competing with Google Meet, Teams, Slack, Gather - way too much tech for collaboration
And I wish we were more async-first and less forced to deal with humans, especially over the network.
I get it, you are VC funded, investors want to turn this into a multi billion dollar unicorn.
Do not focus on investors, but developers.
But personally, what I want in a Code Editor / IDE, is to be the very best experience at writing code and working with code projects. That is what will save me time and make the coding experience better.
Collaborative features are nice but not essential since there are other tools out there. It's not likely to move a team away from Slack (though if it's self-hosted, it stands a chance).
I'm not yet at the point where I can rely solely on Zed for python coding. I mostly use Zed because I like new initiatives, especially open source ones, and it's fast and responsive. But PyCharm is still better for python development at this point, with its one black mark being endless indexing on large codebases / dependencies, and I find myself falling back to it regularly. I would argue that the priority should be to achieve parity as a _code editor / IDE_, and then we can talk about other shiny new features.
But. There are now two times I see Zed going in the wrong direction. The AI integration was one. This feels like the wrong direction again.
I never really liked the AI integration. It felt off to me. I do love coding with Claude and I think I know why. It presents the "information I need to know" in a way my puny brain can handle it. Colored diffs. Summaries of what happened. It isn't perfect, but it has been incredibly productive for me. I never got that from Zed's AI integration; perhaps this has been improved, but I was up and running with Claude in a way that I never was with Zed.
This write-up sounds like "slack in my editor." If it is that, I hate it. Slack has destroyed company culture and communication. People, who are inherently lazy (I'm an old Perl programmer, so I can say that), have stopped thinking carefully and writing carefully, and in that void just throw the first thing in their head into a slack channel and think that is "collaboration" and "communication." It's toxic.
For example, this comment rubs me the wrong way: "Staff members hop in, volunteer to show off a cool feature or bug fix they worked on, and get real-time feedback from the rest of the team." I don't think our human brains work well with "real time feedback" UNLESS we have the information presented in a way that gives us massive clues on what's right and what's wrong. Reading a wall of text is not the way. A colorized git diff, or a video, or an entirely new way of presenting information might make real time feedback possible, but I am highly skeptical a text editor is the way or place to do that. And, I'm an emacs user and love text UIs, don't get me wrong.
Do I want to have "generalized one off rooms for things that don't fit anywhere?" I definitely don't want that. I want you AS THE AUTHOR to be really intentional about what's important and fit that into the proper channels. I need to know that information, but I don't want to know about, nor have the unspoken expectation that I SHOULD have known, about the other stuff. And, I want "managers" (if that still exists) to be carefully thinking about those channels and how the company is organized and push that structure down to people in the organization.
As Zed is the office, having one off rooms instead of in person coffee time feels very dangerous. That's the world a lot of people live in, but I don't like that office.
If this comment is the guiding light, then I'm worried: "We're building toward a future where collaboration is continuous conversation, not discrete commits—where every discussion, edit, and insight remains linked to the code as it evolves, accessible to both teammates and AI agents." I'm human, I have kids, I have other interests. A continuous conversation is impossible for me. I want discrete ideas, and right now, discrete commits and PRs are better, IMHO, than what I hear here. It's hard, but setting the expectation that to be successful I need to be paying attention to a river of information flowing by seems like a bad idea to me. I don't buy that Zed solves the problem of hiding the pieces of information that I don't need to see.
Oh hey! I have an idea. Why not use AI to summarize those conversations into discrete pieces! </joke>
I do love Zed. It is the best GUI editor out there. I know they will get it right. I just am skeptical about this direction and feel it misses the forest for the trees.
But, also, after reading your comments, I'm just not sure I need an "editor" anymore. I love that I can npm install claude anywhere. Zed does not exist for ARM servers yet, but I can install claude there, and it can troubleshoot my database connections, and edit code, and grep files. Those are all the things I used an editor for, because an editor has better ergonomics than using the CLI. I'm sad to say "misspelled prompts" might have better ergonomics for me.
Slack revolutionized this for me because I can turn it off anytime I want. When I want focus, I close it and it cannot reach me for some time. Then I pull it up and read all the threads while taking a poop.
Having it in zed is the same: You can just log out of collab anytime you want! You would only use it if you _want_ to use it. When you do want to use it, it's incredible. Someone can just join your channel and work on a tricky problem with you and you don't even need to screen share. It's like the best of discord and slack available at the touch of a button. It's much lighter weight than slack. Slack huddles are super annoying to me. I want it to behave more like discord, and that's what zed does!
But I still think it is impossible to manage all the things happening in slack. And the expectation is that it was said in slack, so you should know about it! Whereas, I definitely go through and review PRs and if there is a culture and management agreement around good PRs, then I can easily understand how things work, how things have changed, etc. I never get that from slack. And, I never got it from email either, fairly.
It's true, most of them are bad. Galaxy Book5 Pro or Microsoft Surface are OK.
* Has the same level of performance
* With the same or better battery life
* With the same quality of screen
* With the same quality of speakers and touchpad
* Runs as quiet or as cool
as the Apple Silicon macbooks. If you add in "needs to be able to run Linux" your choices go down from maybe 1 or 2 to 0.
They all have some sort of compromise. Either the speakers, screen, keyboard, touchpad, build quality, battery life, or thermals.
I have a Surface Laptop 7 with the Snapdragon X Elite, and it's pretty close. Checks the boxes for Screen, build quality, and touchpad. Loses out on speakers and battery life, and the fans need to run a lot more than my M4 Pro MBP does. It also loses on performance, and it doesn't run Linux. Windows on Arm also still has a lot of little quirks and bugs that start to become daily annoyances.
It's incredibly frustrating. I want, essentially, my 14" M4 MacBook Pro, but in a Linux laptop, and there's no OEM out there that's fulfilling that need without compromises.
Apple keeps pulling ahead in silicon and every other laptop OEM is just being left in the dust, shrugging their shoulders, and putting out the same old 1200p 16:9 plastic garbage they have always been putting out.
for example it’s not out of the question that we could end up with tooling that does truly continuous testing and integration, automatically finding known-good deployments among a continuously edited multiplayer codebase
we’d have to spend a lot more energy on specifications and acceptance testing, rather than review, but I think that’s inevitable - code review can’t keep up with how fast code gets written now
Codex already has a fantastic review mode, and gemini / claude are building tools around pr review that work no matter how that pr was produced, so I think this interface is going to get baked in to how agents work in the near term.
What you describe sounds like a security nightmare to me.
Maybe you are using a remote dev server, and every change you do needs to be committed before you see the result?
Please setup a local environment instead. Not even F5 should be required, you save a file, you see the result in the browser.
When your work is finished, and only then, you should commit your changes.
They would look like noise.
You would be the source of that noise.
One commit per edit? Nonsense.
Me and any other developer would hate to share a repository with you.
In any circle of "what makes a good commit message and why even do it" discussions, invariably the recommendation is to explain the "why" and leave out the self-evident "what".
If your stance is that commit and commit messages can be automated away then we might as well not even have them.
I don't share this view, but yeah in this world we don't need AI to do things that shouldn't be done in the first place.
You can't see any value in being able to see the "what" in a short bit of English at a glance vs having to analyze a 300+ line diff to figure out what it's doing?
Here's a thread where the person replying to me makes this case: https://news.ycombinator.com/item?id=45455963
Doing away with check-ins entirely is the extreme end-game of that pov. I'm in product and every day and every week yes we very much continually change the product!
But I'm growing less convinced that the natural end-state of this methodology produces obviously better results.
You would need to either have separate versions running at the same time or never do breaking changes or devise some other approach that makes it possible.
It's not always feasible to do it this way
