feat: add tips from Zed v0.225.9

tips/agent-panel-restoration.mdx

@@ -0,0 +1,37 @@
+---
+title: Agent Threads Survive Editor Restarts
+subtitle: Your AI conversations now persist across Zed sessions automatically
+category: ai
+difficulty: beginner
+tags:
+  - agent
+  - persistence
+  - workflow
+prUrl: 'https://github.com/zed-industries/zed/pull/48800'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+Previously, restarting Zed meant losing your agent conversation threads, forcing you to start fresh every time. Now, your agent panel state is automatically restored when you reopen your workspace.
+
+## How It Works
+
+Agent panel restoration happens automatically:
+
+1. When you close Zed, your current agent threads are saved
+2. When you reopen the same workspace, your threads are restored
+3. Your conversation history, context, and thread state persist
+
+No configuration needed—it just works.
+
+## Why This Matters
+
+**Continuity**: Pick up exactly where you left off without losing context.
+
+**Workflow Integration**: Agent threads are now part of your workspace, just like open files and panels.
+
+**Reduced Friction**: No more recreating conversations or re-explaining context after restarts.
+
+This is especially valuable for long-running coding sessions where you might need to restart Zed for updates or system maintenance.

tips/audio-device-selection.mdx

@@ -0,0 +1,42 @@
+---
+title: Select and Test Audio Devices for Collaboration
+subtitle: Choose specific microphones and speakers for Zed's built-in collaboration
+category: productivity
+difficulty: beginner
+tags:
+  - collaboration
+  - audio
+  - settings
+  - configuration
+prUrl: 'https://github.com/zed-industries/zed/pull/49015'
+mediaType: image
+mediaUrl: 'https://cat.zed.tips/2026-02-26/audio-device-selection-b9cd8aa5.png'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+When using Zed's collaboration features, you can now select specific audio input and output devices, and test them before joining calls.
+
+## How to Use
+
+1. Open Settings (**`Cmd-,`** on macOS, **`Ctrl-,`** on Linux/Windows)
+2. Navigate to the **Collaboration** page
+3. Select your preferred input device (microphone)
+4. Select your preferred output device (speakers/headphones)
+5. Click **Test** to verify your setup with a playback loop
+
+The test feature routes your microphone input directly to your speakers, so you can hear yourself and confirm everything works.
+
+## Why This Matters
+
+**Device Control**: Use external USB audio interfaces, specific headsets, or any available device.
+
+**Pre-Call Testing**: Verify your audio setup before joining collaboration sessions.
+
+**Multi-Device Workflows**: Switch between different audio setups based on your environment.
+
+**Linux Support**: Especially useful on Linux where audio routing can be complex.
+
+This is invaluable when working remotely with multiple audio devices, external interfaces, or when you need reliable audio for pair programming sessions.

tips/git-init-button.mdx

@@ -0,0 +1,38 @@
+---
+title: Initialize Git Repositories with One Click
+subtitle: Turn any folder into a Git repository directly from the Git panel
+category: git
+difficulty: beginner
+tags:
+  - git
+  - initialization
+  - workflow
+prUrl: 'https://github.com/zed-industries/zed/pull/49203'
+mediaType: video
+mediaUrl: 'https://cat.zed.tips/2026-02-26/git-init-button-0f4a55ab.mov'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+When working in a folder that isn't yet a Git repository, Zed now displays a **Git Init** button in the Git panel, making it effortless to initialize version control.
+
+## How to Use
+
+1. Open a project folder that isn't a Git repository
+2. Open the Git panel (**`Cmd-Shift-9`** on macOS, **`Ctrl-Shift-9`** on Linux/Windows)
+3. Click the **Git Init** button
+4. Your folder is now a Git repository, ready for commits
+
+No need to switch to the terminal or remember Git commands.
+
+## Why This Matters
+
+**Faster Setup**: Start tracking your code in seconds without leaving the editor.
+
+**Beginner Friendly**: No need to remember `git init` or use the command line.
+
+**Seamless Workflow**: Start coding first, add version control when ready.
+
+This is particularly useful when starting new projects or prototypes where you want to focus on coding first and add Git tracking as the project takes shape.

tips/lsp-document-symbols.mdx

@@ -0,0 +1,51 @@
+---
+title: Use LSP Document Symbols in Breadcrumbs and Outline
+subtitle: Switch from tree-sitter to LSP for more accurate code navigation
+category: navigation
+difficulty: intermediate
+tags:
+  - lsp
+  - breadcrumbs
+  - outline
+  - navigation
+prUrl: 'https://github.com/zed-industries/zed/pull/48780'
+mediaType: image
+mediaUrl: 'https://cat.zed.tips/2026-02-26/lsp-document-symbols-bff995e5.png'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+Zed now supports using LSP document symbols instead of tree-sitter for breadcrumbs and outline views, providing more accurate navigation based on your language server's understanding of your code.
+
+## How to Use
+
+Enable LSP document symbols in your language settings:
+
+1. Open your settings with **`Cmd-,`** (macOS) or **`Ctrl-,`** (Linux/Windows)
+2. Add this to your language-specific settings:
+
+```json
+{
+  "languages": {
+    "Rust": {
+      "document_symbols": "on"
+    }
+  }
+}
+```
+
+3. Your breadcrumbs and outline will now use LSP symbols instead of tree-sitter
+
+The setting defaults to `"off"`, using tree-sitter symbols.
+
+## Why This Matters
+
+**LSP Accuracy**: Language servers often have deeper semantic understanding than tree-sitter parsers.
+
+**Consistent Navigation**: Symbols match what your LSP reports, aligning with other IDE features.
+
+**Better for Complex Code**: Particularly useful in languages where tree-sitter has limitations.
+
+This is especially valuable when working with languages that have strong LSP implementations, like Rust, TypeScript, or Go, where the language server provides rich semantic information beyond syntax parsing.

tips/mermaid-diagrams-in-markdown.mdx

@@ -0,0 +1,51 @@
+---
+title: Render Mermaid Diagrams in Markdown Preview
+subtitle: 'Visualize flowcharts, sequences, and diagrams directly in your markdown files'
+category: productivity
+difficulty: beginner
+tags:
+  - markdown
+  - diagrams
+  - documentation
+  - preview
+prUrl: 'https://github.com/zed-industries/zed/pull/49064'
+mediaType: image
+mediaUrl: 'https://cat.zed.tips/2026-02-26/mermaid-diagrams-in-markdown-e3432c24.png'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+Mermaid diagrams now render beautifully in Zed's markdown preview panel, letting you create flowcharts, sequence diagrams, and more using simple text syntax.
+
+## How to Use
+
+1. Open a markdown file in Zed
+2. Add a mermaid code block with your diagram syntax:
+
+```markdown
+\`\`\`mermaid
+graph TD
+    A[Start] --> B{Decision}
+    B -->|Yes| C[Action 1]
+    B -->|No| D[Action 2]
+\`\`\`
+```
+
+3. Open the markdown preview panel
+4. Your diagram renders automatically
+
+Mermaid supports flowcharts, sequence diagrams, class diagrams, state diagrams, and more.
+
+## Why This Matters
+
+**Visual Documentation**: Turn text into diagrams without external tools.
+
+**Version Control**: Diagrams live in markdown, trackable in Git like code.
+
+**No Context Switching**: View and edit diagrams without leaving Zed.
+
+**Always Up-to-Date**: Diagrams are rendered on-demand, so they stay fresh as you edit.
+
+This is perfect for architecture documentation, workflow diagrams, and any technical documentation that benefits from visual representation.

tips/sticky-diff-hunk-controls.mdx

@@ -0,0 +1,39 @@
+---
+title: Sticky Diff Hunk Controls Stay Visible
+subtitle: Keep diff controls accessible even when viewing large changes
+category: git
+difficulty: beginner
+tags:
+  - git
+  - diff
+  - ui
+  - productivity
+prUrl: 'https://github.com/zed-industries/zed/pull/49260'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+When reviewing large diffs, the controls for staging, discarding, or reverting hunks now stick to the top of your viewport, ensuring they're always accessible as you scroll through changes.
+
+## How It Works
+
+Sticky controls activate automatically:
+
+1. Open a file with Git changes
+2. Scroll down through a long diff hunk
+3. When the top of the hunk scrolls off-screen, the controls stick to the viewport top
+4. You can always access hunk actions without scrolling back up
+
+No configuration needed—this works automatically for all diff hunks.
+
+## Why This Matters
+
+**Reduced Scrolling**: Stage or discard hunks without scrolling to the top.
+
+**Better Large Diffs**: Review extensive changes without losing access to controls.
+
+**Faster Workflow**: Make decisions about changes right where you are in the code.
+
+This is especially useful when reviewing substantial changes, like refactoring or feature additions, where diff hunks span many screens and you need quick access to staging controls while examining the full context of the changes.

tips/thinking-effort-controls.mdx

@@ -0,0 +1,39 @@
+---
+title: Control AI Thinking Effort Levels
+subtitle: Adjust how deeply your AI agent reasons through complex problems
+category: ai
+difficulty: intermediate
+tags:
+  - agent
+  - ai
+  - performance
+  - configuration
+prUrl: 'https://github.com/zed-industries/zed/pull/49274'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+When using the Zed provider with supported models, you can now control thinking effort levels to balance between response speed and reasoning depth.
+
+## How to Use
+
+Thinking effort controls appear in the agent panel when using compatible models:
+
+1. Open an agent thread
+2. Look for the thinking effort selector (appears with supported models)
+3. Choose your preferred level based on task complexity
+4. The agent will adjust its reasoning depth accordingly
+
+Higher effort levels provide more thorough analysis at the cost of longer response times.
+
+## Why This Matters
+
+**Task Optimization**: Use lower effort for simple questions, higher effort for complex reasoning tasks.
+
+**Cost Control**: Higher thinking effort may consume more tokens, so you can optimize based on your needs.
+
+**Response Speed**: Get faster responses when deep reasoning isn't necessary.
+
+This feature is particularly useful when you need quick answers for straightforward questions but want deeper analysis for architectural decisions or complex debugging.

tips/toggle-panel-actions.mdx

@@ -0,0 +1,62 @@
+---
+title: Toggle Any Panel with Dedicated Actions
+subtitle: New toggle commands for every panel make custom keybindings easier
+category: shortcuts
+difficulty: beginner
+tags:
+  - panels
+  - keybindings
+  - workflow
+  - ui
+prUrl: 'https://github.com/zed-industries/zed/pull/49395'
+publishedAt: '2026-02-26'
+updatedAt: '2026-02-26'
+author: godruoyi
+authorUrl: 'https://github.com/godruoyi'
+---
+
+Every panel in Zed now has a dedicated toggle action, making it simple to show or hide panels with custom keybindings.
+
+## How to Use
+
+Use the command palette to toggle any panel:
+
+1. Open the command palette (**`Cmd-Shift-P`** on macOS, **`Ctrl-Shift-P`** on Linux/Windows)
+2. Search for "toggle" to see all panel toggle actions
+3. Choose a panel to toggle its visibility
+
+Or create custom keybindings in your keymap settings:
+
+```json
+[
+  {
+    "bindings": {
+      "cmd-1": "workspace::ToggleLeftPanel",
+      "cmd-2": "project_panel::Toggle",
+      "cmd-3": "outline_panel::Toggle"
+    }
+  }
+]
+```
+
+## Available Toggle Actions
+
+All panels now have toggle actions:
+- `project_panel::Toggle`
+- `outline_panel::Toggle`
+- `git_panel::Toggle`
+- `agent_panel::Toggle`
+- `terminal_panel::Toggle`
+- `collab_panel::Toggle`
+- `notification_panel::Toggle`
+- `debugger_ui::Toggle`
+
+## Why This Matters
+
+**Consistent API**: Every panel works the same way for toggling.
+
+**Custom Workflows**: Bind your most-used panels to quick shortcuts.
+
+**Keyboard-First**: Navigate your workspace without touching the mouse.
+
+This is perfect for creating a personalized workspace layout where you can instantly access the panels you need while keeping others hidden until necessary.