I can feel the 30%, looking forward to what's next!

We Rebuilt Zeta from the Training Data Up - Zed Blog Zeta2 is our latest edit prediction model and it's 30% better than Zeta1.

Zeta2 is here. 30% better acceptance rate than Zeta1. 200x more training data, LSP-powered context, faster predictions, open weights. Try it now in Zed.

We didn't just improve the model. We rebuilt the entire data pipeline behind it: zed.dev/blog/zeta2

Is anyone running the Linux version of @zed.dev on an android device yet? I'm curious about the workflow of using phone + portable keyboard + Zed multiplayer + agent panel so I can run prompts remotely, with no need for SSH, and retaining the ability to review agent edits in a multibuffer 🔥🥵🔥

Pretty sure the logo is Inter with a few path tweaks

brand.github.com/GitHub-Brand...

Updated GitHub logos by rezrah · Pull Request #1146 · primer/octicons Updates the GitHub logos (invertocat + full) as part of the 2026 brand refresh. Before After Before After Notes for reviewers: Dimensions are the same for 16 and 2...

GitHub 2026 brand refresh github.com/primer/octic...

For the best code quality, especially on large changes, innovative changes, or tasks where you're not sure of a solution but think the LLM might crack it open for you, you're still gonna want Zed's paid plan + Claude.

If you want zero-cost, the best solution right now is Zed + BYOK connecting to Mistral zed.dev/docs/ai/llm-...

Their devstral models are free, and IME perform well on small-to-medium, relatively well-defined/straightforward/common/known tasks.

Release v3.6.0-beta.1 · vuejs/core Vue 3.6 is now entering beta phase as we have completed the intended feature set for Vapor Mode as outlined in the roadmap! Vapor Mode now has feature parity with all stable features in Virtual DOM...

@vuejs.org 3.6 beta is out with Vapor Mode!
github.com/vuejs/core/r...

The frontend code is all type-safe, too. For example, the return type of this snippet is automatically inferred as an array of game objects:

// Get a list of the user's active games
relatedResources.get({
from: { kind: 'user', id: 'ABC' },
kind: 'is-playing',
to: { kind: 'game' },
})

Examples of frontend code querying the graph payload

Here's a bunch of frontend examples, querying the graph structure to get lists of resources that I can render in a loop:

Pseudo-code describing the data structure I use to describe an app subgraph

This is the data structure I'm using on a project right now. It supports an arbitrary number of different relationships between any two resources in the app, and returns info about where and when the relationship was established.

Across every API and every page load, the payload going over the network is always the same data structure, just with different data, describing different subgraphs in the app.

You never have to design custom API payloads, write custom schemas, or sync custom TS types.

When a user takes an action, update the graph adding new nodes and/or relationships based on the action.

Re-render optimistically. Locally, store events that describe the changes. Depending on your needs, store graph snapshots.

Send the updated graph to your API to sync the backend.

When you load a page, request a subgraph, based on what the user needs and is authorized to see.

On the frontend, write utility functions so you can walk/parse/read/render the graph more ergonomically.

Your app is a graph. Objects are nodes, and their relationships determine graph structure.

User -> TaskList[]
TaskList -> Task[]
User -> User[] (friends)
etc.

User actions change the graph by adding nodes and defining relationships.

*eye twitches*

People give `useEffect` a bad rap, but it isn't usually the source of the problem. The real problem is too many `useState`s.
Devs fail to see how their data is connected and model it too discretely. As those connections appear, it is easier to synchronize than refactor the model. 1/

Life’s Work: An Interview with Esther Duflo The Nobel laureate talks about why she became an economist, how she and her colleagues popularized the use of randomized controlled trials in their field, which tools and interventions have shown succ...

hbr.org/2025/11/life...

I'm a month into Zed and loving it. Multibuffers 🪄

If you play guitar

The solution is Ampero II & Ampero Switch

Play in Stomp mode, using stomps to change scenes (press a single stomp to turn multiple effects on/off, and/or change parameters, with natural delay & reverb spillover, and no audio gaps 🤯)

Use the Ampero Switch to cycle patches

🤘

This comment is art

@zed.dev + claude is S tier for me, maybe slightly lower for people who are heavier into VS Code extensions. The Zed multibuffer is a gamechanger when reviewing agent code, and when refactoring in general

Zed settings Zed settings. GitHub Gist: instantly share code, notes, and snippets.

Been a while since I used @zed.dev, and HOLY SHIT it got good

Multiple cursors editing multiple files, and Claude Code deeply integrated. I've never been able to refactor this fast.

I'm working on my editor settings while the agent runs—here's what I have so far gist.github.com/AlexVipond/a...

I have no clue if this is going to be fast or memory-efficient at scale, but the querying feels great, and I've completely avoided the complexity of Eloquent relationships and helper tables. Gonna make it work before I make it fast

Edge::from('user')->to('location', $request->locationId) ->whereIn('from', $describedUserIds)

Single-table design is magic

This is the Eloquent query I run to get
- lat/lng of the given location
- Profiles of current user & their friends
- Profiles of birds they identified in that location, including timestamps
- Profiles of their multiplayer birding sessions in that location

I think Laravel + single-table design might be groundbreaking stuff, but let me know if you've seen any projects do this! I'm currently running it with Inertia and SQLite, but in theory you could easily swap those out

This works because the entire app is written with a DynamoDB-inspired single-table design.

Resources' profile data is denormalized—I duplicate it and store in a JSON column as needed to support access patterns.

DB writes are complex, but my reads seem cheap and extremely easy so far.

I just wrote the Inertia controller for an app dashboard view that reads 5 types of resources and 16 relationships from the DB.

It uses 1 query, and it does not need to eager-load any model relationships, so I can use the query's cursor() method and iterate over the results with low memory usage.

The only emotion I associate with exclusive accordions is frustration