LazyGit: el gestor visual de Git que vive en tu terminal

Git es poderoso, pero a veces también es tedioso

Todos hemos pasado por esto:

Ejecutar git status para ver qué cambió
Revisar el diff con git diff
Agregar archivos con git add
Escribir el commit con git commit -m
Cambiar de rama con git checkout
Revisar git log para buscar algo
Repetir todo de nuevo

Y no es que sea difícil. Es que son muchos comandos para tareas simples, especialmente cuando haces commits frecuentes o trabajas con múltiples ramas.

Ahí es donde entra LazyGit: una interfaz visual para Git que corre directamente en tu terminal.

Qué es LazyGit y por qué es tan adictivo

LazyGit es una TUI (Terminal User Interface) para Git. Te da paneles visuales para:

ver archivos modificados
navegar el historial de commits
gestionar ramas
resolver conflictos
hacer staging parcial
y mucho más

Todo sin escribir comandos largos. Todo en una sola pantalla.

Es Git, pero con la experiencia de un IDE… sin abrir un IDE.

Instalación

macOS (Homebrew)

brew install lazygit

Linux (via Go)

go install github.com/jesseduffield/lazygit@latest

Arch Linux

sudo pacman -S lazygit

Windows (Scoop)

scoop install lazygit

Una vez instalado, simplemente ejecutas:

lazygit

Y se abre la magia.

Primeras impresiones: qué ves al abrir LazyGit

Al ejecutar lazygit desde cualquier repositorio Git, verás algo así:

┌───────────────────────────────────────────────────────┐
│ Status │ Files │ Branches │ Commits │ Stash │ ...    │
└───────────────────────────────────────────────────────┘

La pantalla se divide en paneles:

Status: resumen del estado actual (rama, commits adelante/atrás)
Files: archivos modificados, staged y untracked
Branches: ramas locales y remotas
Commits: historial de commits
Stash: tus stashes guardados

Navegas con las flechas o con atajos de teclado tipo Vim (j, k, h, l).

Haciendo staging y commits (velocidad real)

Esto es lo que antes te tomaba varios comandos:

git status
git add archivo.js
git diff --staged
git commit -m "mensaje"

En LazyGit:

Te mueves al archivo con flechas
Presionas space para hacer stage
Presionas c para escribir el commit
Enter y listo

El diff se ve en tiempo real al lado del archivo. No hay que adivinar qué estás agregando.

Staging parcial: línea por línea

Una de las funciones más útiles es el staging parcial.

Si solo quieres commitear algunas líneas de un archivo (no todo), en LazyGit:

Seleccionas el archivo
Presionas enter para ver el diff
Navegas a las líneas que quieres
Presionas space para stagear solo esas líneas

Esto en git puro sería git add -p, pero la experiencia de LazyGit es mucho más visual y controlable.

Navegando ramas como un pro

En el panel de ramas puedes:

ver todas las ramas locales y remotas
cambiar de rama con space
crear una nueva rama con n
mergear una rama con M
rebase con r

Y lo mejor: si hay conflictos, LazyGit te abre un flujo visual para resolverlos.

Resolviendo conflictos sin perder la cabeza

Cuando hay un conflicto de merge, LazyGit te muestra:

los archivos en conflicto
los bloques conflictivos marcados
opciones para aceptar “theirs”, “ours”, o editar

Todo desde la misma interfaz, sin tener que abrir el archivo manualmente y buscar las marcas de conflicto.

Es un cambio enorme si alguna vez has sufrido resolviendo merges en proyectos grandes.

Ver historial de commits con contexto

El panel de commits te deja:

navegar el historial
ver el diff de cada commit
hacer checkout de un commit antiguo
cherry-pick un commit a otra rama
revertir un commit
hacer rebase interactivo

Y todo se actualiza en tiempo real. Seleccionas un commit y el diff aparece al lado.

Stash: guardar cambios para después

En el panel de stash:

ves todos tus stashes anteriores
puedes aplicar uno con space
o borrarlo con d
o crear uno nuevo con s desde el panel de archivos

Es una forma mucho más clara de manejar stashes que git stash list, git stash apply stash@{2}, etc.

Rebase interactivo, ahora visual

Uno de los flujos más complejos de Git puro es el rebase interactivo.

En LazyGit:

Seleccionas el commit desde donde quieres hacer rebase
Presionas e para editar
Mueves commits con ctrl+j / ctrl+k
Cambias acciones (squash, edit, reword) con teclas rápidas

Todo sin editar archivos de texto ni memorizar comandos.

Configuración mínima que mejora la experiencia

LazyGit funciona bien por defecto, pero si quieres personalizarlo, crea un archivo en:

~/.config/lazygit/config.yml

Algunas opciones útiles:

gui:
  showCommandLog: true
  theme:
    lightTheme: false

git:
  paging:
    colorArg: always
    pager: delta

Si usas Delta como pager, los diffs se ven aún mejor.

Atajos que vas a usar todo el día

Algunos atajos esenciales:

Tecla	Acción
`space`	stage / unstage archivo
`c`	commit
`p`	push
`P`	pull
`b`	ver branches
`s`	stash
`?`	ver ayuda
`q`	salir

La curva de aprendizaje es baja, y la productividad sube rápido.

LazyGit vs otras herramientas

vs GitKraken / Sourcetree / Fork

Son GUIs completas, pero pesadas y requieren instalar apps externas. LazyGit vive en la terminal, es liviano y se integra bien con flujos de trabajo de devs que ya viven en la terminal.

vs git puro

LazyGit no te aleja de Git. Sigue ejecutando los mismos comandos por debajo, pero te da una capa visual que acelera las tareas repetitivas.

vs Magit (Emacs)

Si usas Emacs, Magit es la referencia. LazyGit es la alternativa para quienes usan otras herramientas y quieren algo similar.

Lo que cambia cuando adoptas LazyGit

No se trata de dejar de saber Git. Se trata de no repetir lo mismo mil veces al día.

Menos comandos escritos
Menos errores de typo en ramas o archivos
Staging más preciso
Conflictos resolubles sin frustración

Es de esas herramientas que parecen pequeñas, pero cambian cómo te sientes al trabajar con Git todos los días.

Y eso, a largo plazo, importa.

~/ 👨‍💻 uncodigo.com _