Zed is a high-performance code editor built in Rust that prioritizes speed, simplicity, and real-time collaboration. Its AI integration is designed to be fast and unobtrusive, with context management built around an assistant panel, inline transformations, slash commands, and a flexible provider system that supports multiple AI services. What sets Zed apart from other AI editors is its focus on performance (everything runs natively, not in Electron) and its built-in multiplayer editing that extends to AI interactions.

This guide covers how to manage context effectively in Zed's AI features to get the most from its lightweight but capable AI integration.

How Zed Manages Context

Zed builds AI context from several sources:

1. Assistant panel - a dedicated panel for multi-turn conversations with persistent context threads
2. Inline transformations - context-aware edits triggered in the editor
3. Slash commands - special commands that inject structured context into prompts
4. Active buffers - files currently open in the editor
5. Project structure - the workspace file tree
6. Custom prompts library - saved, reusable prompt templates
7. Language server data - type information and diagnostics from LSPs
8. MCP servers - external tool connections (supported in recent versions)

Zed takes a minimalist approach to context management: rather than automatically indexing your entire codebase (like Cursor or Windsurf), it gives you explicit control over what goes into context through slash commands and file references.

The Assistant Panel: Structured Conversations

Zed's Assistant Panel is the primary interface for AI interactions that require context beyond the current file. It operates as a structured conversation where you build context explicitly.

How the Panel Works

The panel displays a conversation thread where each message can include code blocks, file references, and slash command outputs. You compose messages, include context, and receive AI responses in a single, reviewable flow.

Persistent Context Threads

Each conversation in the panel is a persistent thread. You can name threads, save them, and return to them later. This means you can maintain ongoing conversations about specific features or architectural decisions without losing context between sessions.

Including Code from Open Buffers

You can drag files or code selections into the assistant panel to include them as context. This explicit inclusion model means you always know exactly what context the AI is working with, unlike tools that silently assemble context behind the scenes.

Zed's Explicit Context Philosophy

Zed's approach to context management is fundamentally different from editors like Cursor or Windsurf that automatically index and retrieve context. In Zed, you explicitly choose what context to provide through slash commands and file inclusions. This has important tradeoffs:

Advantages of explicit context:

• You always know what the AI is working with
• No surprises from irrelevant code being included
• Works well with smaller model context windows (no wasted tokens)
• Context is reproducible: the same slash commands always produce the same context

Tradeoffs:

• Requires more manual effort to set up context
• You need to know which files are relevant before asking
• The AI cannot discover related code on its own (unlike @codebase in other editors)

Understanding this philosophy helps you use Zed's AI features effectively: invest time in selecting the right context rather than expecting the editor to figure it out for you.

Real-Time Collaboration and AI

Zed's built-in multiplayer editing extends to AI interactions. When collaborating in a shared workspace:

• Multiple developers can contribute to the same assistant panel conversation
• One developer can set up the context while another frames the question
• AI suggestions can be reviewed and discussed collaboratively in real time
• The AI's output is visible to all participants simultaneously

This makes Zed uniquely suited for pair programming and team code review workflows that incorporate AI assistance.

Slash Commands: Explicit Context Injection

Slash commands are Zed's primary mechanism for injecting specific types of context into AI conversations.

Available Slash Commands

Using Slash Commands Effectively

The power of slash commands is precision. Instead of sending your entire codebase as context, you choose exactly which files and information are relevant:

/file src/auth/middleware.ts
/file src/auth/types.ts
/diagnostics

I need to fix the TypeScript errors in the auth middleware.
The types file defines the expected interfaces.

This focused approach produces better results than sending the AI a vague question against a massive context window. Each piece of context is intentional and relevant.

/diagnostics for Error-Driven Context

The /diagnostics command is particularly powerful because it pulls language server errors and warnings directly into the AI conversation. Instead of manually copying error messages, one command gives the AI structured diagnostic information.

/fetch for External Documentation

The /fetch command retrieves content from URLs, making it easy to include external documentation, API specifications, or reference material without manual copying:

/fetch https://docs.myframework.com/api/routing

How do I implement nested routing using this framework's API?

Custom Prompts Library

Zed maintains a library of saved prompts that you can reuse across conversations and projects.

Creating Custom Prompts

Navigate to the prompts library and create templates for common tasks:

# Code Review Template

Review the provided code for:
1. Security vulnerabilities (injection, XSS, CSRF)
2. Performance issues (N+1 queries, unnecessary allocations)
3. Error handling completeness
4. Type safety issues
5. Missing edge cases

For each issue found:
- Describe the problem
- Explain the risk
- Provide a fix

Using Prompts

Load a saved prompt with the /prompt slash command:

/prompt code-review
/file src/api/users.ts

This combines your predefined review criteria with the specific file, creating a structured, repeatable workflow.

When to Create Prompts

Create prompts for tasks you perform regularly:

• Code reviews with consistent criteria
• Documentation generation in a specific format
• Refactoring with specific patterns (extract function, apply interface)
• Test generation following your testing conventions

AI Provider Configuration

Zed supports multiple AI providers, giving you flexibility in model selection:

Supported Providers

Context Window Implications

Different providers offer different context window sizes. With Zed's explicit context management (where you choose what to include via slash commands), you have good visibility into how much context you are using. If you are working with a smaller model through Ollama, be more selective with your slash commands. With a large cloud model, you can include more files.

Configuring in settings.json

{
  "language_model": {
    "provider": "anthropic",
    "model": "claude-sonnet-4-20250514"
  }
}

Inline Transformations

For quick edits that do not require a full conversation, Zed's inline transformation feature lets you select code and apply AI-powered changes directly in the editor.

How It Works

1. Select code in the editor
2. Trigger the inline transformation (keyboard shortcut)
3. Type your instruction ("Add error handling" or "Convert to async/await")
4. Zed applies the change inline

Context for Inline Transformations

Inline transformations use a focused context: the current file, the selection, and your instruction. They do not load your custom prompts or conversation history. This makes them fast and appropriate for small, self-contained changes.

MCP Server Support

Recent versions of Zed support MCP for connecting to external tools. The implementation follows the standard MCP pattern: configure servers in settings, and their tools become available within the assistant panel.

Configuration

{
  "context_servers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-postgres"]
    }
  }
}

When to Use MCP in Zed

MCP is most useful when the assistant needs live data (database schemas, API responses, running service status) that cannot be obtained from static files. For code-only tasks, the slash commands and file references are sufficient.

External Documents: PDFs vs. Markdown

Markdown for Everything You Control

Prompts, reference documents, and coding standards should be Markdown. Zed's prompt library and slash commands work natively with text-based formats.

PDFs

Zed does not have built-in PDF parsing. For reference material in PDF form, extract relevant sections into Markdown files in your project and reference them with /file. Alternatively, use /fetch if the content is available online.

Thinking About Context Levels in Zed

Minimal Context (Inline Edits)

Select code, trigger inline transformation, describe the change. The current file and selection provide sufficient context for small changes.

Moderate Context (Feature Work)

Use the assistant panel with targeted slash commands: /file for relevant files, /diagnostics for current errors, /prompt for your coding standards.

Comprehensive Context (Architecture)

Include multiple files via /file or /tab, load architecture documentation via /fetch, and load your team's conventions via /prompt. Build the context explicitly and review it before asking complex questions.

Advanced Patterns

The Multi-File Context Pattern

For changes that span multiple files:

/file src/models/user.ts
/file src/services/userService.ts  
/file src/routes/users.ts
/file tests/services/userService.test.ts

Add a "preferences" field to the User model and propagate it through the service layer, API routes, and tests.

The Diagnostic-Driven Fix Pattern

1. Run your build or test suite
2. Open the assistant panel
3. /diagnostics to load all current errors
4. Ask the AI to fix the errors systematically

The Collaborative AI Pattern

Zed's multiplayer features mean multiple developers can collaborate in real time while using AI. One developer can set up the context (load files, configure the prompt) while another reviews the AI's output. This collaborative workflow is unique to Zed and makes it particularly effective for pair programming with AI assistance.

The Speed-Focused Workflow

For developers who prioritize responsiveness:

1. Use Ollama with a fast local model for inline transformations
2. Use a cloud model for assistant panel conversations that need more capability
3. Keep assistant conversations focused and short
4. Use inline transformations for most edits, reserving the panel for complex tasks

Common Mistakes

1. Over-including context. Zed gives you explicit control over context. Use it wisely. Including every file in your project via /tab when only 2 files are relevant dilutes the AI's focus.

2. Not using saved prompts. If you repeat the same instructions across conversations, save them as prompts. One /prompt code-review is better than retyping your review criteria every time.

3. Ignoring /diagnostics. This command provides structured error context that is faster and more accurate than manually pasting error messages.

4. Using the assistant panel for simple edits. Inline transformations are faster and require less context setup. Use the panel for complex, multi-file work.

5. Not exploring provider options. If response quality is not meeting expectations, try a different model. Zed's multi-provider support makes switching easy.

6. Forgetting /fetch for documentation. External docs can be pulled directly into context without leaving the editor. This is faster and more reliable than manually copying content.

Go Deeper

To learn more about AI-assisted development and context management strategies, check out these resources by Alex Merced:

• The 2026 Guide to AI-Assisted Development covers AI-assisted development workflows, prompt engineering, and context strategies for software engineers.

• The 2026 Guide to Lakehouses, Apache Iceberg and Agentic AI explores how AI agents are reshaping data architecture and how to build systems that support agentic workflows.

And for a fictional take on where AI is heading:

• The Emperors of A.I. Valley: A Novel of Power, Code, and the War for the Future is a novel about the power struggles and ethical dilemmas behind the companies building the most powerful AI systems in the world.