The Neovim + Claude Code + Beam Workflow: Terminal-Native AI Development

February 2026 • 12 min read

Neovim users are the most terminal-native developers on the planet. If you use Neovim, you have already made a deliberate choice: you want to live in the terminal. You think in keystrokes. You compose tools rather than click buttons. You have spent hours configuring your setup to be exactly right.

So when it comes to AI-assisted coding, why would you leave the terminal? You should not. Instead, add Claude Code as your AI pair programmer and Beam as your workspace organizer, and you get the ultimate terminal-native development environment. No Electron apps. No browser tabs. No mouse. Just terminals, arranged exactly the way you want them.

This guide walks through the complete Neovim + Claude Code + Beam workflow: how to set it up, how the development loop works, language-specific configurations, and why this stack replaces traditional IDEs for developers who take their tools seriously.

Why This Stack Works

Every tool in this stack does exactly one thing, and does it well. That is the Unix philosophy, and it is exactly how Neovim users already think about software.

Neovim handles editing. It is the best editor for people who think in keystrokes. Modal editing, composable commands, Lua configuration, treesitter-powered syntax highlighting, and a plugin ecosystem that puts most IDEs to shame. If you already use Neovim, you know all this. The point is: Neovim is your editor, and it should stay that way.

Claude Code handles AI assistance. It runs in a terminal. It understands your entire codebase. It reads files, writes files, generates code, debugs problems, writes tests, and handles git operations. It is not a plugin inside your editor trying to autocomplete single lines. It is a full AI agent that works alongside you.

Beam handles workspace organization. It gives you workspaces, tabs, split panes, saveable layouts, and a Quick Switcher to jump between everything. It is the connective tissue that keeps Neovim and Claude Code organized across multiple projects.

The key insight: everything runs in a terminal. Zero context switching to GUI applications. Zero reaching for the mouse. Zero waiting for Electron to render. This is what terminal-native AI development actually looks like.

The Beam Layout for Neovim Users

There are two primary layouts that work well for the Neovim + Claude Code workflow. Which one you prefer depends on whether you like seeing Claude Code's output while you type, or whether you prefer full-screen Neovim and switch contexts deliberately.

Layout 1: The Side-by-Side Split

This is the most popular layout. Split your Beam window into two panes:

• Left pane (60%) — Neovim, running full height. This is where you write code.
• Right pane (40%) — Split vertically into two sections:
  • Top right — Claude Code session, where you ask questions and receive suggestions
  • Bottom right — A regular shell for running builds, tests, or git commands

Press &CommandMac;&Option;&Control;T to create the split in Beam. Then resize the panes by dragging the divider. The 60/40 ratio gives Neovim enough room for 80+ character lines while keeping Claude Code's output readable.

Layout 2: The Tab-Based Workflow

If you prefer full-screen Neovim and do not want any visual distraction while editing, use tabs instead of splits:

• Tab 1 — Neovim (full screen, maximum focus)
• Tab 2 — Claude Code (full screen for reading longer responses)
• Tab 3 — Build and test output (cargo watch, jest --watch, etc.)
• Tab 4 — Git operations or ad-hoc shell commands

Switch between tabs with &CommandMac;1 through &CommandMac;4. The muscle memory builds fast: &CommandMac;1 to edit, &CommandMac;2 to talk to Claude Code, &CommandMac;3 to check test output.

Both layouts work with Beam's Quick Switcher (&CommandMac;P). If you have multiple projects open across different workspaces, the Quick Switcher lets you fuzzy-search across all of them and jump to any tab or pane instantly. This is similar to telescope.nvim's file finder, but for your terminal workspaces.

The Workflow Loop

This is the core of the Neovim + Claude Code + Beam workflow. It is a tight, keyboard-driven loop that keeps you moving fast without ever reaching for the mouse.

Step 1: Write Code in Neovim

You are in Neovim, writing code as usual. You use your LSP for diagnostics, treesitter for syntax highlighting, and whatever other plugins you have configured. This is your primary creative space.

Step 2: Ask Claude Code for Help

When you hit a decision point, a bug, or want a review, switch to the Claude Code pane. If you are using the split layout, this is just Ctrl-W l if Claude Code is in Neovim's built-in terminal, or a Beam pane switch. If you are using the tab layout, press &CommandMac;2.

Tell Claude Code what you need:

"Review what I just wrote in src/handler.rs and suggest improvements"
"Write tests for the parse_config function in src/config.rs"
"There's a race condition in my worker pool — help me debug it"
"Refactor this module to use the builder pattern"

Claude Code reads the file directly from disk, understands the context of your entire project, and gives you a detailed response. It can also write files directly, which means the changes appear in Neovim immediately if you have autoread enabled.

Step 3: Apply Changes in Neovim

If Claude Code wrote changes to disk, just reload in Neovim (:e or let autoread handle it). If Claude Code suggested changes in its response, switch back to Neovim and apply them manually. You have full control.

Step 4: Watch Tests Run

In your third pane or tab, you have a file watcher running your test suite. Every time Claude Code writes a file or you save in Neovim, the tests re-run automatically. You see green or red without any manual intervention.

Step 5: Repeat

This loop — write, ask, apply, verify — is remarkably fast. There is no waiting for a GUI to update. No switching between applications. No loading spinners. Every step happens in the terminal, and every transition is a keystroke.

Neovim + Claude Code Integration Tips

Here are specific techniques for making Neovim and Claude Code work together more smoothly within Beam.

Use Claude Code's File Reading

Claude Code can read any file in your project directly. When you switch to the Claude Code pane, you do not need to copy-paste code from Neovim. Just tell Claude Code which file you want it to look at:

Review src/handler.rs, focusing on the error handling in handle_request

Claude Code will read the file, understand the context, and respond. This is much faster than selecting text in Neovim and piping it somewhere.

Enable Autoread in Neovim

When Claude Code writes changes to files, you want Neovim to pick them up automatically. Add this to your Neovim config:

-- In your init.lua
vim.opt.autoread = true

-- Auto-check for file changes when you focus the buffer
vim.api.nvim_create_autocmd({ "FocusGained", "BufEnter" }, {
    command = "checktime",
})

Now when you switch from the Claude Code pane back to Neovim, any file changes are loaded automatically. No manual :e! needed.

Clipboard Sharing Between Panes

Beam shares the system clipboard across all panes and tabs. If you yank text in Neovim (with "+y to use the system register), you can paste it in the Claude Code pane to provide context. Vice versa, if Claude Code outputs a snippet you want, select it in the Claude Code pane and paste it in Neovim.

Make sure your Neovim config uses the system clipboard:

vim.opt.clipboard = "unnamedplus"

Neovim's Built-in Terminal vs. Beam's Panes

Neovim has a built-in terminal (:term). You could technically run Claude Code inside Neovim's terminal. But this has drawbacks: the terminal buffer shares Neovim's screen space, scrollback is limited by Neovim's terminal emulation, and switching between terminal mode and normal mode adds keystrokes.

The better approach: run Claude Code in a dedicated Beam pane alongside Neovim. You get the full terminal experience with unlimited scrollback, proper color rendering, and you can interact with Claude Code without leaving terminal mode. Use Neovim's built-in terminal only for quick one-off commands.

tmux Inside Beam: When It Makes Sense

If you are a tmux user, you might wonder whether to use tmux inside Beam or use Beam's native tabs and splits. The short answer: use Beam's native features for workspace-level organization, and tmux only if you need session persistence over SSH.

• Local development — Use Beam's tabs and splits. The Quick Switcher, keyboard shortcuts, and saveable layouts are better than tmux for local workflow management.
• Remote development (SSH) — Use tmux inside a Beam tab. tmux keeps your session alive if the SSH connection drops. Beam keeps your local workspace organized.

Project Memory for Neovim Workflows

One of the most powerful features of Claude Code is project memory via CLAUDE.md files. These are markdown files at the root of your project that tell Claude Code about your codebase: the architecture, conventions, build commands, and anything else that helps it give better suggestions.

For Neovim-centric workflows, your CLAUDE.md should include your coding conventions so that Claude Code generates code that matches your style:

# Project: my-api

## Build
- `cargo build` to compile
- `cargo test` to run tests
- `cargo watch -x test` for continuous testing

## Architecture
- src/handler.rs — HTTP request handlers
- src/models/ — Data models with serde
- src/db/ — Database layer using sqlx

## Code Conventions
- Use Result<T, AppError> for all fallible functions
- Prefer impl Trait over Box<dyn Trait>
- Error handling: use thiserror for custom errors
- No unwrap() in production code
- Tests go in the same file, in a #[cfg(test)] module

Beam's Install Memory Feature

Beam has an "Install Project Memory" toolbar button that writes your project context to CLAUDE.md in one click. Instead of manually creating and maintaining this file, let Beam handle it. When you start a new Claude Code session, the AI already knows your project's conventions, structure, and build commands.

This is especially useful when you switch between multiple projects. Each Beam workspace can have its own project directory, and when you open Claude Code in that workspace, it automatically loads the right memory file.

Include Your Neovim Conventions

Here is something most guides miss: put your Neovim-specific conventions in the memory file. If you use specific formatting settings, indentation preferences, or code organization patterns enforced by your Neovim config, tell Claude Code about them:

## Editor Conventions (Neovim)
- Indent: 4 spaces (not tabs)
- Max line length: 100 characters
- Trailing whitespace is auto-removed on save
- Files end with a newline
- Imports are sorted by conform.nvim

Now Claude Code generates code that looks like it came from your hands, not from an AI. No reformatting needed after applying suggestions.

Language-Specific Setups

Different languages benefit from different Beam workspace configurations. Here are optimized setups for the most common languages used with Neovim + Claude Code.

Rust: Neovim + rust-analyzer + Claude Code + cargo watch

Rust development is one of the best use cases for this workflow because the compile-test cycle is inherently terminal-driven.

• Neovim LSP: rust-analyzer via nvim-lspconfig
• Tab 1: Neovim with rust-analyzer providing inline diagnostics, code actions, and type hints
• Tab 2: Claude Code for architecture decisions, complex trait implementations, and debugging borrow checker issues
• Tab 3: cargo watch -x test for continuous testing, or cargo watch -x "clippy -- -W warnings" for lint-on-save

Claude Code is particularly good at Rust because it understands lifetime annotations, trait bounds, and async patterns that trip up most developers. Ask it to explain a borrow checker error and you will get a clear explanation with a fix, not just a suggestion to add .clone().

Go: Neovim + gopls + Claude Code + go test

• Neovim LSP: gopls via nvim-lspconfig
• Tab 1: Neovim with gopls providing diagnostics and auto-imports
• Tab 2: Claude Code for generating table-driven tests, interface implementations, and concurrency patterns
• Tab 3: go test ./... -v or use gotestsum --watch for continuous output

Go's simplicity makes it ideal for this workflow. Claude Code generates idiomatic Go quickly, and gopls catches any issues immediately in Neovim.

TypeScript: Neovim + ts_ls + Claude Code + jest --watch

• Neovim LSP: ts_ls (TypeScript language server) via nvim-lspconfig
• Tab 1: Neovim with full TypeScript diagnostics and auto-imports
• Tab 2: Claude Code for React component generation, type gymnastics, and API integration
• Tab 3: jest --watch or vitest --watch for continuous testing
• Tab 4: npm run dev for the development server

TypeScript projects often need more terminals because you have separate build, test, and dev server processes. Beam's tab system keeps these organized without the clutter of multiple terminal windows.

Python: Neovim + pyright + Claude Code + pytest

• Neovim LSP: pyright via nvim-lspconfig
• Tab 1: Neovim with pyright providing type checking and diagnostics
• Tab 2: Claude Code for data pipeline architecture, pandas operations, and FastAPI endpoint generation
• Tab 3: pytest-watch or ptw for continuous testing

For Python data science work, add a fourth tab with an IPython shell for interactive exploration. Claude Code can generate code that you test interactively in IPython before committing to your source files.

Replacing the IDE: What You Gain

The question every Neovim user eventually asks about AI coding tools: can I get the same AI features without switching to VS Code or Cursor? The answer is yes, and here is what you gain by staying in the terminal.

The composability advantage is the most important one. In the IDE model, the AI is a feature inside the editor. If the AI integration is bad, you are stuck. In the terminal model, each tool is independent. You can upgrade Neovim without affecting Claude Code. You can switch from Beam to another terminal organizer without touching your Neovim config. The tools are loosely coupled, which means you can optimize each one independently.

Speed: No Electron Overhead

Neovim starts in under 100ms, even with 50+ plugins. Claude Code is a CLI tool with near-zero startup time. Beam is a native macOS application, not an Electron wrapper. The entire stack uses a fraction of the memory that VS Code alone consumes. On an M-series Mac, this setup feels instantaneous.

Works Everywhere SSH Does

This is the capability that GUI IDEs cannot replicate well. SSH into a remote server, start tmux, open Neovim, run Claude Code. Your entire development environment is now running on the remote machine. No VS Code Remote SSH extension, no port forwarding, no latency from rendering a GUI over the network. Beam manages your local workspace while tmux keeps the remote session alive.

Neovim Plugins That Complement Claude Code

With Claude Code handling AI assistance, you do not need AI-specific Neovim plugins like Copilot.vim or CodeCompanion.nvim. Instead, focus your Neovim plugin setup on the things Claude Code does not do: file navigation, diagnostics display, and git integration.

telescope.nvim — Fuzzy Finding

Telescope is the Neovim equivalent of Beam's Quick Switcher, but for files within a project. Use telescope to find and open files, search for symbols, and grep through code. When Claude Code tells you to check a specific file, telescope gets you there in two keystrokes.

-- Telescope keymaps
vim.keymap.set("n", "<leader>ff", "<cmd>Telescope find_files<cr>")
vim.keymap.set("n", "<leader>fg", "<cmd>Telescope live_grep<cr>")
vim.keymap.set("n", "<leader>fb", "<cmd>Telescope buffers<cr>")

trouble.nvim — Diagnostics

Trouble gives you a clean list of all LSP diagnostics (errors, warnings) in your project. When Claude Code makes changes to multiple files, open trouble to see if anything broke. It is a faster feedback mechanism than waiting for the test suite.

oil.nvim — File Management

Oil turns your file system into an editable buffer. Create, rename, move, and delete files using normal Neovim editing commands. When Claude Code creates new files, use oil to organize them without leaving Neovim.

lazygit.nvim — Git Integration

Lazygit gives you a full TUI git interface inside Neovim. Stage changes, write commits, manage branches, and resolve merge conflicts. Alternatively, you can use Claude Code for git operations — it handles commits, diffs, and branch management natively. Use whichever feels faster for the operation at hand.

conform.nvim — Formatting

Auto-format on save so that code Claude Code generates and code you write look identical. Configure conform with your project's formatter (rustfmt, gofmt, prettier, black) and formatting becomes invisible.

A Minimal Plugin List for This Workflow

If you are setting up a fresh Neovim configuration optimized for the Claude Code workflow, here is a focused plugin list:

• lazy.nvim — Plugin manager
• nvim-lspconfig — LSP configuration for your languages
• nvim-treesitter — Syntax highlighting and code objects
• telescope.nvim — Fuzzy finder for files, symbols, and grep
• oil.nvim — File system editing
• trouble.nvim — Diagnostics list
• conform.nvim — Auto-formatting
• gitsigns.nvim — Git change indicators in the gutter
• mini.nvim — Collection of small, useful modules (surround, comment, pairs)

That is nine plugins. No bloat. Everything else — AI assistance, workspace management, project memory — is handled outside Neovim by Claude Code and Beam.

Advanced: Multi-Project Orchestration

When you are working on a system with multiple services (a common pattern in backend development), the Neovim + Claude Code + Beam workflow scales naturally.

Workspace Per Service

Create a Beam workspace for each service:

• Workspace "api-gateway" — Neovim + Claude Code + test runner for the API gateway
• Workspace "auth-service" — Neovim + Claude Code + test runner for the auth service
• Workspace "frontend" — Neovim + Claude Code + dev server for the frontend
• Workspace "infrastructure" — Neovim + Claude Code for Terraform/Docker configs

Each workspace has its own Claude Code session, so the AI maintains separate context for each service. No cross-contamination of project knowledge. Switch between workspaces with &CommandMac;&Option;←→ or use the Quick Switcher (&CommandMac;P) to jump directly to any tab in any workspace.

Cross-Service Debugging

When a bug spans multiple services, you need to look at code in different projects simultaneously. With Beam workspaces, you can quickly switch between the API gateway's Claude Code session and the auth service's Neovim instance. Ask Claude Code in each workspace about its respective service, then piece together the full picture.

This is where Beam's Quick Switcher really shines. Type a few characters of the service name and jump directly to the relevant tab, regardless of which workspace it is in.

Getting Started

Here is how to set up the Neovim + Claude Code + Beam workflow from scratch:

1. Install Beam — Download from getbeam.dev. It is a native macOS app.
2. Install Claude Code — Run npm install -g @anthropic-ai/claude-code in any terminal.
3. Set up Neovim — If you do not have a config, start with kickstart.nvim and customize from there.
4. Create your first workspace — Open Beam, press &CommandMac;N to create a workspace, name it after your project.
5. Set up your layout — Create tabs or splits for Neovim, Claude Code, and your test runner.
6. Create a CLAUDE.md — Add your project description, build commands, and code conventions.
7. Save the layout — Press &CommandMac;S so you can restore this setup any time.
8. Start coding — Write code in Neovim, ask Claude Code for help, watch tests pass.

The first time you go through the write-ask-apply-verify loop entirely in the terminal, without touching a mouse or switching to a GUI app, you will understand why this workflow exists. It is not about being anti-GUI. It is about removing every unnecessary millisecond of friction between thinking and doing.

Summary

The Neovim + Claude Code + Beam workflow is for developers who believe the terminal is the best development environment. Here is what you get:

• Neovim for editing — modal, composable, and fast enough to keep up with your thoughts
• Claude Code for AI assistance — a full AI agent that understands your codebase, runs in a terminal, and reads/writes files directly
• Beam for organization — workspaces, tabs, splits, saveable layouts, and Quick Switcher to manage everything
• Zero GUI overhead — no Electron, no browser tabs, no mouse required
• Language-agnostic — works the same way for Rust, Go, TypeScript, Python, or anything else
• Composable — each tool does one thing well, and you can swap any piece without breaking the others
• Works over SSH — the entire stack runs in a terminal, so remote development is native

If you already use Neovim, you are 90% of the way there. Add Claude Code for AI. Add Beam for workspace management. That is the whole stack.

Happy coding.