LazyVim · Guías

Movimiento y navegación

Acción	Atajo
Moverse un carácter	`h` `j` `k` `l`
Palabra siguiente / anterior	`w` / `b`
Fin de la palabra actual	`e`
Inicio / fin de línea	`0` o `^` / `$`
Inicio / fin del archivo	`gg` / `G`
Ir a la línea N (ej. `42G`)	`NG`
Media página arriba / abajo	`Ctrl`+`u` / `Ctrl`+`d`
Párrafo anterior / siguiente	`{` / `}`
Ir al par `( ) [ ] { } < >`	`%`
Saltador ultra rápido (Flash): `s` y 2 letras	`s`

Explorador de archivos (Neo-tree)

Acción	Atajo
Abrir / cerrar el explorador	`<leader>e`
Enfocar el archivo actual en el árbol	`<leader>fE`

Dentro de Neo-tree:

Acción	Atajo
Crear archivo o carpeta (si termina en `/`, crea una carpeta)	`a`
Eliminar archivo o carpeta	`d`
Renombrar / mover	`r` / `m`
Copiar / cortar / pegar	`c` / `x` / `p`
Ver archivos ocultos (`.env`, etc.)	`H` o `i`
Ver archivos ignorados (`.gitignore`)	`I` o `g`
Abrir en split horizontal / vertical	`s` / `v`

Búsqueda y Live Grep

Acción	Atajo
Buscar archivos por nombre	`<leader>Espacio`
Buscar texto en el proyecto (Live Grep)	`<leader>/` o `<leader>sg`
Buscar texto en el buffer actual	`<leader>sb`
Buscar la palabra bajo el cursor	`<leader>sw`
Buscar en archivos recientes	`<leader>fr`
Buscar símbolos y funciones	`<leader>ss`
Buscar en el historial de commits	`<leader>gc`
Buscar comandos y keymaps	`<leader>sk`
Buscar la palabra actual en el archivo	`*` (adelante) / `#` (atrás)

Buffers, splits y tabs

Acción	Atajo
Navegar entre buffers abiertos	`Shift`+`h` / `Shift`+`l`
Cerrar el buffer actual	`<leader>bd`
Fijar (pin) un buffer importante	`<leader>bp`
Cerrar todos los buffers no fijados	`<leader>bP`
Split horizontal	`<leader>w-`
Split vertical	`<leader>w\|`
Moverse entre ventanas	`Ctrl`+`h/j/k/l`
Cerrar la ventana actual	`<leader>wd`
Maximizar / restaurar la ventana	`<leader>wm`

LSP y navegación de código

Acción	Atajo
Ir a la definición (función o clase)	`gd`
Buscar todas las referencias	`gr`
Ir a la implementación	`gI`
Ir a la definición de tipo	`gy`
Ver documentación y firma (hover)	`K`
Renombrar un símbolo en todo el proyecto	`<leader>cr`
Formatear el documento actual	`<leader>cf`
Volver a la posición previa	`Ctrl`+`o`
Avanzar a la posición siguiente	`Ctrl`+`i`

Errores y acciones de código (Trouble)

Acción	Atajo
Ver las acciones disponibles (code actions)	`<leader>ca`
Ver el detalle del error en la línea actual	`<leader>cd`
Siguiente diagnóstico / error	`]d` / `]e`
Anterior diagnóstico / error	`[d` / `[e`
Abrir la lista completa de errores	`<leader>xx`
Abrir los errores del buffer actual	`<leader>xX`
Ver la lista de TODO, BUG, HACK	`<leader>st`

Frontend, Angular y Tailwind

Acción	Atajo
Saltar del componente TS a su template HTML (con el cursor sobre `templateUrl`)	`gd`
Ir a la etiqueta HTML de cierre (con el cursor sobre `<div>`)	`%`
Cambiar el contenido dentro de una etiqueta	`cit` (change inner tag)
Borrar la etiqueta completa y conservar el contenido	`dat`
Autocompletado de Tailwind CSS con vista previa de color	`Ctrl`+`Espacio` / `Tab`
Formatear HTML, CSS y Angular con Prettier	`<leader>cf`

El autocierre y el autorenombrado de etiquetas HTML funcionan solos con el plugin nvim-ts-autotag.

Terminal, Bash y Git

Acción	Atajo
Abrir la terminal flotante	`<leader>ft` o `Ctrl`+`/`
Ocultar la terminal flotante	`EscEsc` o `Ctrl`+`/`
Abrir LazyGit (interfaz interactiva de Git)	`<leader>gg`

Bash sin salir de Neovim:

Acción	Comando
Ejecutar un comando
Ejemplo: listar archivos ocultos
Insertar la salida de un comando en el archivo
Filtrar una selección con un comando (ej. `jq`)

Markdown

El renderizado dentro del buffer viene activado en LazyVim con render-markdown.

Acción	Atajo o comando
Alternar el renderizado de Markdown
Previsualizar en el navegador
Atajo para la previsualización en el navegador	`<leader>cp`
Marcar o desmarcar un checkbox `[ ]` (sobre la línea)	`Espacio`

Activar módulos con :LazyExtras

LazyVim trae módulos preconfigurados para Angular, Tailwind CSS, Prettier, Python, TypeScript, Docker, Terraform, YAML e IA. Ejecuta :LazyExtras en Neovim y presiona x sobre cada paquete que quieras instalar:

Módulo	Qué incluye
`lang.angular`	Angular Language Service (LSP)
`lang.tailwindcss`	Tailwind LSP y colorizer para el autocompletado
`formatting.prettier`	Formateador para HTML, CSS, JS/TS y Angular
`lang.python`	Pyright, Ruff, Debugpy y VirtualEnv
`lang.typescript`	Vtsls (TS/JS) y ESLint
`lang.docker` y `lang.terraform`	Dockerfiles, Compose y HCL LSP
`ai.avante`	Asistente de IA nativo, estilo Cursor
`ai.claudecode`	Claude Code (la vía recomendada)

Flujo de trabajo con Angular

Con lang.angular activo, la lógica en TypeScript y la plantilla HTML quedan conectadas:

Pon el cursor sobre templateUrl: './app.component.html' y presiona g d para saltar al HTML.
Las plantillas autocompletan variables del componente, pipes y directivas de Angular (*ngIf, @for).

Tailwind CSS y HTML

Sugerencias de clases de Tailwind con vista previa del color al escribir dentro de class="...".
Prettier formatea al guardar. También puedes usar <leader> c f o guardar con Ctrl + s.

Configuración Lua del stack

Guarda este archivo en ~/.config/nvim/lua/plugins/stack_config.lua:

lua · neovim

return {
  -- 1. Python & FastAPI: VirtualEnv selector
  {
    "linux-cultist/venv-selector.nvim",
    dependencies = { "neovim/nvim-lspconfig", "nvim-telescope/telescope.nvim" },
    opts = { name = { "venv", ".venv", "env", ".env" }, auto_refresh = true },
    keys = {
      { "<leader>cv", "<cmd>VenvSelect<cr>", desc = "Select VirtualEnv (Python)" },
    },
  },

  -- 2. HTML / Angular: auto close and rename tags
  {
    "windwp/nvim-ts-autotag",
    opts = {
      opts = {
        enable_close = true,
        enable_rename = true,
        enable_close_on_slash = true,
      },
    },
  },

  -- 3. Tailwind CSS & CSS: show colors inline in the buffer
  {
    "roobert/tailwindcss-colorizer-cmp.nvim",
    opts = { color_square_width = 2 },
  },

  -- 4. Markdown preview in the web browser
  {
    "iamcco/markdown-preview.nvim",
    cmd = { "MarkdownPreviewToggle", "MarkdownPreview", "MarkdownPreviewStop" },
    ft = { "markdown" },
    build = function() vim.fn["mkdp#util#install"]() end,
    keys = {
      { "<leader>cp", "<cmd>MarkdownPreviewToggle<cr>", desc = "Markdown Preview Web" },
    },
  },

  -- 5. AI assistant (Avante.nvim, Cursor style)
  {
    "yetone/avante.nvim",
    event = "VeryLazy",
    opts = { provider = "copilot" },
  },
}

Kiro CLI en LazyVim (kiro.nvim)

Puedes invocar los CLIs de IA sin salir del editor, montándolos como plugins de lazy.nvim con su propio atajo.

Acción	Atajo o comando
Abrir / cerrar Kiro CLI	`<leader>tk`
Comando equivalente del plugin
Cargar el plugin manualmente
Salir del modo insertar de la terminal	`Ctrl`+`\` `Ctrl`+`n`
Volver al modo insertar (escribirle a Kiro)	`i` / `a`
Moverse entre ventanas (código y Kiro)	`Ctrl`+`h/j/k/l`

Instalación

Crea ~/.config/nvim/lua/plugins/kiro.lua:

lua · neovim

return {
  {
    'srirammv/kiro.nvim',
    config = function()
      require('kiro').setup()
    end,
    keys = {
      { '<leader>tk', '<cmd>KiroToggle<cr>', desc = 'Toggle Kiro CLI' },
    },
  }
}

Guarda el archivo y reinicia Neovim, o ejecuta :Lazy sync para que lazy.nvim descargue el plugin.
Verifica el estado del plugin con :Lazy.
Presiona <leader> t k para alternar la interfaz de Kiro CLI.

Requisito de tmux: esta integración usa tmux, así que debes correr Neovim dentro de una sesión.

bash

tmux new -s dev
nvim .

Alternativa sin tmux: lanza el binario kiro con toggleterm.nvim y mapea el mismo atajo <leader> t k.

Claude Code en LazyVim (claudecode.nvim)

Acción	Atajo o comando
Enfocar o abrir la sesión de Claude	`<leader>af`
Adjuntar el buffer actual al contexto	`<leader>ab`
Enviar la selección (modo visual)	`<leader>as`
Seleccionar el modelo de Claude	`<leader>am`
Enfocar la sesión activa
Iniciar una sesión nueva
Enviar texto o selección
Agregar un archivo al contexto

Vía recomendada: extra oficial

Abre Neovim y ejecuta :LazyExtras.
Baja hasta la sección ai.
Selecciona claudecode y presiona x.
Reinicia Neovim para que lazy.nvim instale el plugin.

Antes de abrir Neovim, instala y autentica el CLI de Claude Code, y comprueba que el comando claude (o claude-code) funciona en tu shell:

bash

which claude
claude --version

Configuración manual

Crea ~/.config/nvim/lua/plugins/claudecode.lua:

lua · neovim

return {
  {
    "coder/claudecode.nvim", -- Official wrapper of the Claude Code IDE extension
    dependencies = {
      "nvim-lua/plenary.nvim",
      "ibhagwan/fzf-lua", -- Optional: file pickers and session switching
    },
    cmd = { "ClaudeCodeFocus", "ClaudeCodeNew", "ClaudeCodeSend" },
    keys = {
      { "<leader>af", "<cmd>ClaudeCodeFocus<cr>",       desc = "Focus Claude Code" },
      { "<leader>ab", "<cmd>ClaudeCodeAdd %<cr>",      desc = "Add Buffer to Claude" },
      { "<leader>as", ":ClaudeCodeSend<cr>", mode = "v", desc = "Send Selection to Claude" },
      { "<leader>am", "<cmd>ClaudeCodeSelectModel<cr>", desc = "Select Claude Model" },
    },
    opts = {
      -- Custom plugin overrides here
    },
  }
}

Usa solo una de las dos vías. Si ya activaste ai.claudecode en :LazyExtras, este archivo solo sirve para sobrescribir atajos u opts.