The Complete Guide to Zed: A Fast, Modern Editor for Python Developers

Zed. Code at the speed of thought.

Mar 08, 2026

Why Zed? (30-Second Pitch)

~200ms cold start. ~73MB RAM. GPU-rendered at 120 FPS. Written entirely in Rust by the creators of Atom and Tree-sitter.

If you want the full pitch — why Rust matters, how GPUI renders your editor like a video game, why ACP will make Zed the universal AI host while Cursor stays locked in — I wrote that blog already: Cursor vs Zed: Pick Your Weapon.

This post isn’t about why. This is about how.

Install (60 Seconds)

# macOS
brew install --cask zed

# Linux
curl -f https://zed.dev/install.sh | sh

# Windows — download from zed.dev

Open Zed. No welcome tour. No tip of the day. No popups. Just an editor.

Extensions (2 Minutes)

Cmd+Shift+X → install these:

Essential: Python, Ruff, Docker, SQL

Recommended: TOML, YAML, Markdown, Make, Terraform

That’s it. A lot of what needs extensions in VS Code — git, terminal, debugger, collaboration, Vim mode, REPL — is native in Zed.

Steal My Settings

I maintain two settings files:

v2 (Recommended) — simplified, “autopilot mode.” Good global defaults, languages inherit everything, override only what differs.
v1 — fully documented, every setting explained with all possible values. Great for learning Zed’s config surface.

→ GitHub Gist — Zed Settings

Before you paste:

Font: Install FiraCode Nerd Font. The config assumes it.
AI models: Update the provider/model to match your setup. I use Claude Opus 4.6 via copilot_chat.
Save behavior: I don’t auto-save. Cmd+S triggers format-on-save hooks (Ruff sorts imports, fixes lint, formats). This will modify your buffer. Adjust if that surprises you.

The Setup, Explained

The rest of this post explains the why behind my settings. Skip to whatever’s relevant.

The Python Formatter Chain

When you press Cmd+S, three things fire in order:

Ruff organizes imports — sorts, groups, removes unused
Ruff fixes all auto-fixable lint issues — upgrades syntax, removes dead code
Ruff formats — consistent style, enforced line length

No Black. Ruff handles everything. I used a 4-step chain with Black as a “final pass” for months. Ruff’s formatter produces identical output in every case I care about. Removing Black shaved ~200ms off every save.

Two Language Servers, One Editor

"language_servers": ["pyright", "ruff"]

Order matters. Pyright first — completions, type information, go-to-definition, hover docs. Ruff second — fast linting and formatting.

Both run simultaneously. Pyright returns completions while Ruff returns diagnostics while you keep typing. No blocking. This is what Tree-sitter + parallel LSP communication in Rust gives you — something Electron editors structurally can’t match.

Virtual Environment: `.venv/bin/python`

Pyright needs to know where your Python lives. .venv is the uv default, and if you’re not using uv yet, that’s a different conversation (but here’s the Lightning Blog).

Ruff: `filesystemFirst`

This one’s subtle but critical:

"configurationPreference": "filesystemFirst"

Ruff walks up the directory tree from the current file, looking for pyproject.toml or ruff.toml. If it finds one, project config wins. The Zed settings become fallback defaults.

Without this, your editor silently overrides your project’s lint rules. You’d never notice. Your CI would.

Lint Rules

"select": ["E", "W", "F", "I", "UP", "B", "SIM"]

E/W — pycodestyle errors and warnings. The basics. F — Pyflakes. Dead imports, undefined names. I — isort. Import ordering. UP — pyupgrade. Modernizes syntax to your target Python version. B — flake8-bugbear. Catches common bugs and design problems. SIM — flake8-simplify. “You wrote 6 lines. This could be 1.”

No E501 (line too long) — the formatter handles line length. Don’t lint what you format.

SQL: PostgreSQL Grammar

"prettier": {
    "plugins": ["prettier-plugin-sql"],
    "language": "postgresql",
    "keywordCase": "upper"
}

The postgresql grammar means Prettier won’t choke on ILIKE, LATERAL, or :: casts. keywordCase: "upper" enforces SELECT, FROM, WHERE — scannable at a glance. Override per-project with "language": "mysql" if needed.

The “Inherit Everything” Philosophy

My v2 config sets global defaults once:

tab_size: 4
preferred_line_length: 88
soft_wrap: "editor_width"
format_on_save: "on"
prettier: { "allowed": true }

Every language inherits these. The Python block only specifies what’s different — language servers and the formatter chain. The SQL block only specifies its formatter and Prettier config. Dockerfile only turns off format-on-save.

Less duplication. Fewer places to forget when you change a global preference.

AI Setup

I route everything through copilot_chat as the provider — it’s a model marketplace. Claude, Gemini, GPT, Grok, all through one GitHub Copilot subscription. No separate API keys.

Default model + inline assistant: Claude Opus 4.6
Edit predictions: Copilot
Default profile: "ask" — the agent confirms before making changes
Sound on completion: On. Because dopamine.

Dark Mode, Obviously

"theme": {
    "mode": "dark",
    "dark": "One Dark"
}

We’re not savages.

Keybindings Worth Memorizing

WhatShortcutCommand paletteCmd+Shift+PQuick file openCmd+PGo to definitionF12Find referencesShift+F12Multi-cursor (all matches)Cmd+Shift+LInline AI assistantCmd+KAgent panelCmd+?Accept edit predictionTabToggle terminalCtrl+`Zed ModeCmd+Shift+EnterStart debuggingF5Toggle breakpointF9

Zed Mode — Cmd+Shift+Enter. Everything vanishes except your code. Press again to restore. This is where deep work lives.

Multi-buffer editing — Cmd+Shift+F to search across your project. Edit directly in the results. Changes apply to actual files. Refactoring on steroids.

Debugging Python

Drop this in .zed/debug.json:

[
    {
        "label": "Debug Current File",
        "adapter": "debugpy",
        "request": "launch",
        "program": "${file}"
    }
]

Or skip the config entirely — click the play button in the gutter next to test functions. Zed auto-detects pytest.

What’s Still Missing

Being honest:

Extensions — VS Code has 60,000+. Zed has hundreds. The essentials are covered. Google Cloud Code, visual Kubernetes manager — not yet.

Jupyter Notebooks — built-in REPL with inline outputs exists, but full .ipynb UI is coming 2026. For heavy notebook workflows, Cursor/VS Code still wins.

Refactoring — not as comprehensive as PyCharm’s automated refactoring tooling. Yet.

Go

Install Zed. Paste my settings. Open a project. Press Cmd+Shift+Enter.

Feel the focus.

Vikas’s Substack

Discussion about this post

Ready for more?