Claude Code + Vim, Helix, JetBrains — the editor-agnostic AI workflow

Claude Code runs in a terminal. That fact is the entire reason this guide exists. If your editor is anything that lives in a terminal-adjacent workflow (Vim, Neovim, Helix) or anything that has a built-in terminal pane (JetBrains, VS Code), Claude Code works with it without an editor-specific plugin.

IndyDevDan”s July 7 video — “I”m HOOKED on Claude Code Hooks” — captures the editor-agnostic operating model that crystallized through summer 2025: the agent loop lives in the terminal, the editor is where you read and approve changes, and the integration between them is mostly your shell ergonomics. Dan”s broader thesis through July (Plan Mode workflow, 3 oddly useful repos) extends the same pattern.

But the r/neovim community spent the same months asking a harder question: does AI coding break the joy of editing for the engineers who actually picked Vim/Helix/JetBrains for their editor-as-craft ergonomics? This guide is the working answer.

The editor-agnostic setup

Claude Code is one terminal command (claude). You run it; it spawns an agent loop in your shell; it reads and writes files in your current working directory; it shows you diffs and asks for approval. Your editor sees the file changes via filesystem watch.

The minimum viable setup for any editor:

# 1. Install Claude Code (one-time)
npm install -g @anthropic-ai/claude-code

# 2. From your project root, start Claude
cd ~/projects/your-project
claude

# 3. Your editor sees the files Claude touches via FS events
# Vim/Neovim: :checktime to reload changed files
# Helix: auto-reload on focus
# JetBrains: auto-reload on focus (with prompt)
# VS Code: auto-reload on focus

That”s it. Nothing else is required for basic editor-agnostic Claude Code use.

Per-editor refinements

Vim / Neovim

The minimum-viable Vim setup is :checktime on returning to the editor, but you can do better:

Auto-reload on focus:

" In your vimrc or init.vim
autocmd FocusGained,BufEnter * :checktime

" Auto-reload when files change externally
set autoread

Run Claude Code in a tmux pane next to Vim. The canonical power-user pattern: tmux split, Vim on the left, Claude on the right, file changes flow Vim ← Claude via filesystem.

For Neovim specifically: The r/neovim “Support for Agent Client Protocol in CodeCompanion.nvim” thread (276 upvotes, Aug 27) documents the more integrated path. CodeCompanion.nvim with ACP (Agent Client Protocol) support lets you talk to Claude Code from inside Neovim without leaving the editor at all. This is the way forward for Neovim users who want tight integration. Avante.nvim is the popular alternative for those wanting a Cursor-like experience inside Neovim.

Helix

Helix has fewer plugins than Neovim, which is part of the appeal. The Claude Code workflow is similar:

# Auto-reload changed files (Helix does this on focus by default)
# Run Claude in tmux pane or terminal split

# Helix-specific: configure language server to refresh on FS events
# Most LSPs do this by default

The “Helix + Claude Code” pattern is more pure than the Neovim version — Helix users tend to value the “less plugin sprawl” philosophy, and Claude Code-in-terminal matches that ethos. The editor stays focused on editing; the agent stays focused on agent-loop work.

JetBrains (IntelliJ, PyCharm, GoLand, etc.)

JetBrains has the most polished “auto-reload changed files” UX of any editor — prompts you with a clear diff when files change externally, lets you accept/reject per file.

Run Claude Code in the built-in JetBrains Terminal pane. Cmd-J (Mac) / Alt-F12 (Linux/Windows) opens it. The terminal inherits your project working directory automatically.

Use JetBrains” Local History feature as a safety net. If Claude makes a change you don”t like, JetBrains” per-file Local History lets you revert without git involvement.

Per-file external-change handling:

• Settings → Tools → Reload Files Changed on Disk
• Set to “Auto-detect” (default) for unsaved files
• Set to “Auto-reload” for files you”re not actively editing

VS Code (included for completeness)

VS Code has the most extensions; you”re not the target audience for this guide if you”re on VS Code. The minimal Claude Code setup is the same: terminal pane, run claude, files auto-reload.

IndyDevDan”s editor-agnostic workflow framework

Dan”s July-August content cluster frames the broader pattern that any editor user should adopt:

1. Hooks for observability. Claude Code Hooks let you run scripts at lifecycle events (pre-prompt, post-response, on tool use). Useful for: logging agent actions, running linters automatically, tracking which files Claude touched.

2. Plan Mode for senior-engineer workflow. Plan Mode makes Claude generate a plan before making changes. You review the plan in any editor (it”s just markdown), approve or reject, then Claude executes. This is the editor-agnostic pattern par excellence — the plan is text, your editor can render it however it wants.

3. Slash commands for common operations. /review, /test, /refactor work regardless of which editor you”re in. Templates live in .claude/commands/ in your repo; they”re project-portable.

4. Sub-agents for parallel work. Sub agents that build themselves — the most advanced pattern Dan covers — work entirely in terminal. Your editor sees the resulting file changes; the agent orchestration happens out of sight.

The r/neovim philosophical question

The r/neovim “AI steals fun in coding, is nvim the cure?” thread (253 upvotes, Jul 31) is the canonical statement of the concern:

“Throughout my 6y+ career as ML Engineer I genuinely enjoyed the process of writing code. But now I feel like cursor is stealing the joy in this process. At my work it”s almost expected by now that you are using some kind of AI copilot or cursor / claude code…”

Top response (70 upvotes): “This is actually the reason I switched to Neovim.”

The “Are we the dying tribe of craftsmen in the Industrial revolution of AI?” thread (151 upvotes, Jul 2) extends the worry. Top comment (135 upvotes):

“I use neovim with Claude Code and don”t feel like I”m missing anything by not using Cursor.”

The Neovim community”s working answer to “is Claude Code compatible with editor-craft”: yes, when used as a tool that respects the editor”s primacy rather than replacing it. The editor-agnostic pattern (Claude in terminal, editor for review and refinement) preserves what Vim/Helix users love about their editors while accessing the agent loop”s productivity.

Creator POV vs Reddit dissent

Dan”s POV is engineering-pragmatic — pick whatever editor you want, use Claude Code as the agent layer, don”t fight either tool. His broader thesis: the editor is now infrastructure, the agent loop is where productivity lives.

The Neovim community POV is craft-protective but pragmatic — preserve editing-as-thinking, use AI where it helps, don”t let AI dictate your editing ergonomics. The r/neovim “next edit prediction” thread (129 upvotes, Jul 26) shows the same community experimenting with Copilot-style inline predictions in Neovim — wanting the benefits without abandoning the editor.

The Helix community is quieter, more aligned with “less plugin sprawl” philosophy. JetBrains users tend to lean on the IDE”s built-in refactoring tools alongside Claude Code rather than replacing them.

The mature read: editor choice and AI-coding choice are now mostly orthogonal. Pick the editor that fits your hands; use Claude Code as the terminal agent; let them coexist via filesystem.

What this means for working engineers

Three concrete starting positions:

1. If you”re already on Vim / Helix / JetBrains, don”t switch editors for AI. Cursor/Windsurf aren”t the only paths. Claude Code in terminal works with your existing editor. The migration cost is zero; the productivity gain is significant.

2. Adopt Plan Mode as your default. Dan”s Plan Mode workflow reduces wasted agent loops and gives you editor-friendly markdown plans to review. Works the same in any editor.

3. If you”re on Neovim, evaluate CodeCompanion.nvim + ACP for deeper integration. The August 27 release thread (276 upvotes) is the right starting point. Avante.nvim is the alternative for Cursor-style ergonomics.

The honest critique

What editor-agnostic Claude Code doesn”t solve:

• Inline AI predictions still require editor-specific integration. If you want Copilot-style ghost-text suggestions while typing, you need an editor plugin. Claude Code doesn”t do this.
• The “agent runs in another pane” workflow has cognitive overhead. Context-switching between editor and terminal is real friction; mitigated by tmux/vim integration but not eliminated.
• Cursor and Windsurf still have UX advantages for some workflows — visual diff acceptance, file tree integration, multi-file edit-in-place. Editor-agnostic Claude Code sacrifices those for portability.

For most working engineers who already love their editor: Claude Code is the agent layer that doesn”t require you to give up the editor. Set up tmux, learn Plan Mode, configure hooks for your project, and accept that the future of AI coding is editor-agnostic — which is good news for everyone who picked Vim, Helix, or JetBrains for reasons that don”t change just because models got better.

For broader Claude Code workflow context, see our Personal Claude Code workflow guide and cursorrules best practices (the underlying agent-discipline patterns apply across editors).