Hay un momento muy concreto en el que Neovim deja de sentirse como un editor de texto y empieza a sentirse como una extensión de tu forma de pensar. No llega instalando quince plugins ni memorizando un cheatsheet completo. Llega cuando dejas de preguntarte “¿cómo abro este archivo?” y simplemente lo abres, sin pensar en el comando.

Ese momento tarda en llegar sobre todo cuando el proyecto con el que trabajas es grande. Un scraper con quince archivos .go repartidos en seis paquetes no es lo mismo que un script suelto. Ahí es donde la navegación deja de ser un detalle y se convierte en el cuello de botella real de tu productividad.

Vamos a construir ese flujo desde cero, empezando por lo que Neovim ya trae incorporado.

El problema no es Neovim, es el modelo mental

Cuando vienes de un editor con pestañas visibles y un árbol de archivos siempre abierto a la izquierda, tu cerebro espera ver la estructura del proyecto todo el tiempo. Neovim no funciona así por defecto, y tratar de forzarlo a comportarse como VS Code suele terminar en frustración.

El modelo mental correcto es distinto: en vez de ver dónde están los archivos, saltas a ellos. La diferencia es sutil pero cambia todo. No necesitas tener un árbol de directorios permanentemente visible si puedes llegar a cualquier archivo en menos de dos segundos escribiendo parte de su nombre.

Con esa idea en la cabeza, lo que sigue tiene mucho más sentido.

Netrw: el explorador que ya tienes instalado

Antes de instalar nada, prueba esto:

:Ex

Ese comando abre Netrw, el explorador de archivos nativo de Neovim. No es bonito, no tiene iconos, pero funciona y no requiere ninguna configuración.

:Ex       " abre el explorador en el directorio actual
:Sex      " lo abre en un split horizontal
:Vex      " lo abre en un split vertical

Dentro del explorador te mueves con j y k como en cualquier parte de Neovim, entras a un directorio o abres un archivo con Enter, y subes un nivel con -.

Es perfectamente usable para un vistazo rápido. Donde empieza a quedarse corto es cuando ya sabes el nombre del archivo que quieres y no te apetece navegar visualmente hasta él. Ahí entra el segundo mecanismo nativo.

Buffers: la forma en que Neovim entiende “archivos abiertos”

Si vienes de otros editores, es fácil asumir que “pestaña” y “archivo abierto” son lo mismo. En Neovim, el concepto es el buffer, y es más flexible de lo que parece al principio.

:e internal/scraper/client.go
:e internal/models/novel.go

Cada :e abre un archivo y, si no existía ya, crea un buffer nuevo. Para ver todo lo que tienes abierto:

:ls

Vas a ver algo como esto:

  1 %a   "internal/scraper/client.go"     line 42
  2  h   "internal/models/novel.go"       line 1
  3  h   "internal/database/sqlite.go"    line 15

Con esos números puedes saltar directo a cualquiera:

:b3       " ir al buffer 3
:bn       " siguiente buffer
:bp       " buffer anterior
:bd       " cerrar el buffer actual

La ventaja frente a un árbol de archivos visible es que no necesitas espacio en pantalla para esto. Los buffers viven en memoria, no en la interfaz, y los invocas cuando los necesitas.

Jumplist: el comando que más vas a usar sin darte cuenta

De todo lo nativo, este es probablemente el que más impacto tiene en el día a día, y el que menos se enseña.

Ctrl-o     " salta a la posición anterior
Ctrl-i     " salta a la posición siguiente

Piensa en esto como el botón de “atrás” y “adelante” del navegador, pero para tu historial de edición dentro de Neovim. Si estás leyendo client.go, saltas a cdp_client.go para revisar cómo se conecta al WebSocket, y luego quieres volver exactamente a la línea donde estabas en client.go, Ctrl-o te lleva ahí sin que tengas que recordar el archivo ni la línea.

Esto funciona entre archivos distintos, no solo dentro del mismo buffer. Es la diferencia entre navegar linealmente (abrir, cerrar, volver a abrir) y navegar como si fuera un grafo de posiciones por el que te mueves libremente.

Buscar dentro del proyecto sin salir del editor

El último ingrediente nativo es la búsqueda de texto en todos los archivos:

:grep -r "FetchDocument" .
:copen

:grep ejecuta la búsqueda y llena la quickfix list, una lista de resultados navegable. :copen la muestra en un panel inferior. Desde ahí, Enter sobre cualquier línea te lleva directo a esa posición en el archivo correspondiente.

:ccl      " cerrar la lista de resultados

Si en el proyecto del scraper quisieras rastrear cada lugar donde se llama a FetchDocument —desde cmd/catalog/main.go hasta el pool de workers— esto te da el mapa completo en segundos, sin salir del editor ni depender de un plugin externo.

Cuándo lo nativo ya no alcanza

Con Netrw, buffers, jumplist y :grep puedes leer y navegar un proyecto de tamaño mediano sin ningún plugin. Es una base sólida y vale la pena dominarla antes de añadir nada encima, porque entender estos mecanismos hace que cualquier plugin posterior tenga más sentido: en el fondo, la mayoría de los plugins de navegación no inventan conceptos nuevos, hacen más ágiles estos mismos.

La señal de que necesitas algo más aparece de forma bastante clara: cuando :ls seguido de :b3 empieza a sentirse lento porque tienes que memorizar números de buffer que cambian constantemente, o cuando vuelves al mismo puñado de archivos —digamos, los cuatro o cinco puntos clave de un flujo que estás trazando— decenas de veces en una sesión.

Ahí es donde entra Harpoon.

Harpoon: marcar y saltar, sin nada más

La idea de Harpoon es deliberadamente simple: marcas un archivo, y luego saltas a él con una combinación de teclas fija, sin importar en qué otro archivo estés en ese momento.

{ "ThePrimeagen/harpoon", branch = "harpoon2" }

local harpoon = require("harpoon")

vim.keymap.set("n", "<leader>a", function() harpoon:list():add() end)
vim.keymap.set("n", "<C-e>", function() harpoon.ui:toggle_quick_menu(harpoon:list()) end)

vim.keymap.set("n", "<C-1>", function() harpoon:list():select(1) end)
vim.keymap.set("n", "<C-2>", function() harpoon:list():select(2) end)
vim.keymap.set("n", "<C-3>", function() harpoon:list():select(3) end)
vim.keymap.set("n", "<C-4>", function() harpoon:list():select(4) end)

Volviendo al ejemplo del scraper: marcas client.go, cdp_client.go, novel.go y worker.go con <leader>a mientras los visitas la primera vez. A partir de ahí, Ctrl-2 te lleva a cdp_client.go sin importar si estabas en worker.go o en el archivo de migraciones. No hay búsqueda de por medio, no hay lista que recorrer: es un salto directo.

La diferencia con la jumplist nativa es de intención. La jumplist es tu historial —lo que ya visitaste—. Harpoon es una selección deliberada de los archivos que sabes que vas a necesitar una y otra vez durante esa sesión de trabajo.

Telescope, cuando necesitas encontrar en vez de recordar

Harpoon resuelve “quiero volver a estos cuatro archivos”. Pero a veces el problema es distinto: no sabes exactamente dónde está algo, solo sabes cómo se llama o qué texto contiene.

{ "nvim-telescope/telescope.nvim" }

local builtin = require("telescope.builtin")

vim.keymap.set("n", "<leader>ff", builtin.find_files)
vim.keymap.set("n", "<leader>fg", builtin.live_grep)
vim.keymap.set("n", "<leader>fb", builtin.buffers)

<leader>ff abre un buscador difuso de archivos: escribes fragmentos del nombre y Telescope filtra en tiempo real. <leader>fg hace lo mismo pero buscando contenido dentro de los archivos, con vista previa incluida. Es la versión con esteroides de :grep — mismo concepto, pero interactivo y con contexto visual inmediato.

Cómo se ve todo esto junto, en la práctica

Para el proyecto del scraper, un flujo realista de una sesión de lectura se vería así:

  1. Abres Neovim en la raíz del proyecto: nvim .
  2. :Ex para ubicarte y confirmar la estructura de directorios
  3. Entras a internal/models/novel.go, lo lees, y lo marcas con Harpoon
  4. Vuelves con - en Netrw o con Ctrl-o, entras a internal/scraper/client.go, lo marcas también
  5. Mientras lees client.go, ves que llama a algo definido en cdp_client.go — saltas ahí directamente con :e, lo marcas
  6. Quieres saber en cuántos lugares se usa FetchDocument — <leader>fg y lo escribes
  7. Revisas los tres o cuatro resultados, y en cada uno usas Ctrl-o para volver al punto anterior si necesitas comparar
  8. A partir de ahí, te mueves entre tus archivos marcados con Ctrl-1, Ctrl-2, Ctrl-3 sin volver a pensar en rutas

Nada de esto exige memorizar treinta atajos. Son cuatro o cinco mecanismos que se combinan naturalmente, y cada uno resuelve un problema distinto: Netrw para ubicarte, buffers para tener cosas abiertas, la jumplist para retroceder, Harpoon para anclar tus puntos de referencia, y Telescope para cuando necesitas buscar en vez de recordar.

Empieza por lo nativo

Si estás configurando Neovim desde cero, como es tu caso ahora mismo en Sway, la recomendación honesta es no instalar Harpoon ni Telescope el primer día. Pasa al menos una semana usando solo Netrw, buffers y la jumplist en proyectos reales. Vas a notar exactamente en qué momento se queda corto ese flujo, y cuando instales un plugin para resolverlo, vas a entender de inmediato por qué existe y qué problema concreto resuelve — en vez de copiar una configuración ajena sin saber qué hace la mitad de las teclas.

Esa diferencia, entre instalar algo porque lo viste en un video y instalarlo porque ya sentiste el problema que resuelve, es la que separa una configuración de Neovim que entiendes de una que simplemente heredaste.