Infra15 min de lectura
Git sin complicaciones: stash, amend, fetch, rebase y reflog
Git sin miedo: git stash, git mv, commit --amend, fetch vs pull, rebase vs merge, rebase interactivo, push --force-with-lease y el reflog para deshacer casi todo.

¿Te da miedo usar Git? ¿Lo máximo que haces es git add, git commit y git push, y el resto de los comandos te asusta? No eres la única persona.
Git parece intimidante porque casi cada comando toca un lugar distinto, y nadie te muestra el mapa. Cuando entiendes dónde actúa cada comando, deja de ser un monstruo y se vuelve una herramienta que te salva cada semana.
Publiqué la primera versión de este post en Medium en 2023, en portugués. Esta es la versión revisada: mejores explicaciones, algunos errores míos corregidos y cada comando probado de nuevo.
Aquí explico los comandos que más uso además de commit y push, con ejemplos que ejecuté de verdad en un repositorio de prueba: git stash, git mv, git commit --amend, git fetch, git rebase (y el interactivo) y, al final, git reflog, que deshace casi cualquier error.
TL;DR#
git stashguarda en un cajón los cambios que aún no hiciste commit, ygit stash poplos devuelve. Los archivos nuevos solo entran con-u.git mves un atajo demv+git add. Git no guarda renombres: los deduce por el contenido. Para ver el historial de un archivo renombrado, usagit log --follow.git commit --amendcambia el último commit por uno nuevo. Ideal para un archivo olvidado o un mensaje equivocado, siempre que el commit aún no se haya subido.git fetchsolo descarga y actualizaorigin/main. No toca tu código.git pullesfetch+merge(orebase).git rebasevuelve a aplicar tus commits sobre otra base y deja el historial en línea recta. El interactivo (-i) junta, edita y reordena commits.- ¿Reescribiste historial que ya estaba subido? Usa
git push --force-with-lease, nunca--force(ni+branch). En mi prueba,+mainborró el commit de una compañera sin avisar. - ¿Algo salió mal?
git refloglista todo por donde pasó tuHEAD, ygit reset --hard HEAD@{n}te devuelve ahí.
El mapa: dónde actúa cada comando#
Antes de los comandos, el dibujo que me hizo entender Git. Hay cinco lugares, y cada comando lleva cambios de uno a otro:
- Directorio de trabajo: los archivos que editas.
- Stash: un cajón para guardar cambios sin hacer commit.
- Index (o staging): lo que va a entrar en el próximo commit, después de
git add. - Repositorio local: tus commits, en tu máquina.
- Remoto: GitHub (o GitLab, Bitbucket). Tu máquina guarda una copia de lo último que vio allí,
origin/main.
Guarda este mapa. Casi toda confusión con Git viene de creer que un comando actúa en un lugar cuando actúa en otro.
git stash: el cajón#
Estás en medio de una tarea, con archivos modificados, y necesitas cambiar de branch para corregir un bug urgente. Hacer commit del trabajo a medias queda feo. git stash guarda los cambios en un cajón y deja el directorio limpio:
git stash push -m "wip: signup form"
git switch hotfix/login
# ...fix the bug, commit, push...
git switch feature/signup
git stash popUn detalle que atrapa a mucha gente: un archivo nuevo, que Git todavía no rastrea, no va al cajón. En mi prueba, después de git stash, el archivo nuevo seguía ahí:
$ git stash push -m "wip: signup form"
Saved working directory and index state On main: wip: signup form
$ git status --short
?? draft.txtPara llevar los archivos nuevos también, usa -u (de --include-untracked):
git stash push -u -m "wip: signup form"El
git stash save "nombre"que aparece en tutoriales viejos está obsoleto. La forma actual de ponerle nombre esgit stash push -m "nombre".
¿pop o apply?#
Los dos devuelven los cambios del cajón al directorio de trabajo. La diferencia es qué pasa con el cajón:
git stash applyaplica y mantiene el stash en la lista. Útil para aplicar el mismo cambio en más de una branch.git stash popaplica y borra el stash de la lista. Esapplyseguido degit stash drop.
Con una excepción: si el pop da conflicto, no borra nada. Git mismo te avisa:
Auto-merging app.txt
CONFLICT (content): Merge conflict in app.txt
...
The stash entry is kept in case you need it again.Resuelves el conflicto y después borras el stash con git stash drop cuando tengas la certeza de que ya no lo necesitas.
Otros comandos del cajón:
git stash list # every stash, newest first: stash@{0}, stash@{1}...
git stash show -p stash@{1} # what is inside one of them
git stash pop stash@{1} # bring back a specific one
git stash drop stash@{1} # delete onegit mv: renombrar y mover#
git mv renombra o mueve un archivo y deja el cambio listo para el commit:
git mv index.html home.html # rename
git mv index.html public/ # move
git mv scripts src/scripts # folders tooLa primera versión de este post decía que git mv existe para "no perder el historial". Yo también lo creía, y no es exactamente así. Git no guarda renombres. Guarda el contenido de los archivos en cada commit y, a la hora de mostrarlo, compara: si un archivo desapareció y apareció otro casi igual, concluye que fue renombrado.
Por eso, mv + git add -A da exactamente el mismo resultado. Probé los dos, y git status muestra lo mismo:
$ git mv index.html home.html
$ git status --short
R index.html -> home.html
$ mv home.html start.html && git add -A
$ git status --short
R home.html -> start.htmlLa R es Git diciendo "detecté un renombre". git mv solo te ahorra un paso.
¿Y el historial? El git log de un archivo se detiene en el renombre. Para seguir el archivo por sus nombres anteriores, usa --follow:
$ git log --oneline -- home.html
3b727de rename index to home
$ git log --oneline --follow -- home.html
3b727de rename index to home
a366c0e add index pageConsejo: renombra en un commit y cambia el contenido en otro. Si renombras y reescribes la mitad del archivo en el mismo commit, Git puede no reconocer que es el mismo archivo, y ahí ni --follow encuentra el historial.
¿Cambiaste de idea antes del commit? Solo renómbralo de vuelta con git mv home.html index.html.
git commit --amend: arreglar el último commit#
"git amend" no existe como comando. Lo que existe es la opción --amend de git commit, que cambia el último commit por uno nuevo.
Olvidaste un archivo:
git add forgotten-file.ts
git commit --amend --no-edit # same message, new contentTe equivocaste en el mensaje:
git commit --amend -m "feat: rename the home page"Lo que poca gente nota es que el commit no se edita, se reemplaza. Fíjate en el hash cambiando con cada --amend en mi prueba:
22b393b rename again # before
f5024f2 rename again # after --amend --no-edit
4c2a0e4 feat: rename the home page # after --amend -mDe ahí la regla: usa --amend solo en commits que aún no subiste. Si ya está en el remoto y alguien lo descargó, vas a necesitar un push forzado (más sobre eso al final) y esa persona va a quedarse con un commit que ya no existe.
git fetch: mirar antes de traer#
git fetch descarga lo nuevo del remoto y actualiza origin/main, esa copia del remoto que vive en tu máquina. No toca tu branch ni tus archivos. Es como leer los titulares sin abrir el periódico.
$ git fetch origin
From ../origin
4c2a0e4..8d7de9d main -> origin/main
$ git status -sb
## main...origin/main [behind 1]
$ git log --oneline main..origin/main
8d7de9d feat: add the profile pagemain..origin/main lista los commits que están en el remoto y todavía no están en tu main. Ves lo que llegó antes de decidir traerlo.
¿Y git pull? Es fetch seguido de un merge (o de un rebase, si lo configuras). Descarga y junta en tu branch, todo de una vez:
git pull # fetch + merge
git pull --rebase # fetch + rebasePrefiero hacer fetch antes cuando la branch es compartida o cuando pasé días sin actualizar. Así veo el tamaño del cambio antes de que el conflicto me estalle en la cara.
Traer cambios de otro repositorio#
fetch también funciona con cualquier remoto, no solo origin. Ejemplo: tienes un fork y quieres las novedades del proyecto original. Agrégalo como un segundo remoto:
git remote add upstream https://github.com/original-author/project.git
git fetch upstream
git merge upstream/mainupstream es solo un apodo, como origin. Después resuelves los conflictos (si los hay), haces commit y push a tu fork.
git rebase: volver a aplicar los commits sobre otra base#
Creaste una branch, hiciste dos commits, y mientras tanto alguien subió un commit nuevo a main. Para traer lo que entró en main, hay dos caminos:
git mergecrea un commit de merge que une las dos historias. No se reescribe nada.git rebasetoma tus commits y los vuelve a aplicar uno por uno sobre lamainnueva, como si hubieras empezado la branch ahora. El historial queda en línea recta.
En mi prueba, mi main local tenía dos commits que origin/main no tenía, y origin/main tenía uno que yo no tenía:
* 0df7909 wip
* 6f1f89e add z
| * 8d7de9d feat: add the profile page (origin/main)
|/
* 4c2a0e4 feat: rename the home pageDespués de git rebase origin/main:
* 2b2bea3 wip
* 4f1c163 add z
* 8d7de9d feat: add the profile page
* 4c2a0e4 feat: rename the home pageMis dos commits subieron, en línea recta, con hashes nuevos (0df7909 se volvió 2b2bea3). Ese es el punto clave del rebase: no mueve commits, crea commits nuevos con el mismo contenido.
¿Cuál usar? Ninguno es mejor, y muchos equipos eligen uno por defecto. La regla que importa es una sola: no hagas rebase de commits que otras personas ya descargaron. En tu branch, antes de abrir el PR, adelante.
Rebase interactivo: ordenar los commits antes del PR#
git rebase -i abre una lista con los commits y te deja decir qué hacer con cada uno:
git rebase -i HEAD~3 # the last 3 commitspick 4f1c163 # add z
pick 2b2bea3 # wip
pick 060be7b # fix typo
# Rebase 8d7de9d..060be7b onto 8d7de9d (3 commands)Debajo de esa lista, Git mismo explica los comandos. Los que más uso:
pick: mantiene el commit como está.reword: lo mantiene, pero abre el editor para cambiar el mensaje.edit: se detiene en ese commit para que cambies lo que quieras (archivos, autor) y despuésgit rebase --continue.squash: lo junta con el commit de arriba y combina los mensajes.fixup: lo junta con el commit de arriba y descarta el mensaje de este.drop: borra el commit.
Cambias la palabra al inicio de cada línea, guardas y cierras. Para juntar wip y fix typo en el commit de arriba, por ejemplo:
pick 4f1c163 # add z
fixup 2b2bea3 # wip
fixup 060be7b # fix typoPara editar varios mensajes, cambia pick por reword. Git se va deteniendo en cada uno y abre el editor.
Si el editor no abre (o abre Vim y no sabes salir), configura VS Code:
git config --global core.editor "code --wait"El --wait hace que Git espere a que cierres la pestaña antes de seguir.
Commits con el nombre o el e-mail equivocado#
Un clásico de computadora nueva: olvidaste configurar user.name y user.email, y los commits salieron como root@localhost. Primero, configúralos:
git config --global user.name "Your Name"
git config --global user.email "you@example.com"Después, para corregir solo el último commit:
git commit --amend --no-edit --reset-authorPara corregir varios, en lugar de marcar edit uno por uno como yo hacía, usa --exec, que ejecuta un comando después de cada commit reaplicado:
git rebase origin/main --exec "git commit --amend --no-edit --reset-author"Fíjate en origin/main en lugar de HEAD~10. Toma solo los commits que todavía no están en el remoto, o sea, solo los tuyos. En mi prueba, usé HEAD~2 y uno de los dos era el commit de una compañera, que ya estaba en el remoto. El rebase cambió su autor por el mío sin preguntar. Contar commits con HEAD~n es fácil de errar. Usar la base correcta, no.
Push forzado sin borrar el trabajo de los demás#
Todo comando que reescribe historial (--amend, rebase) crea commits nuevos. Si los viejos ya estaban en el remoto, el git push normal es rechazado, porque el remoto tendría que tirar commits. Ahí entra el push forzado.
La primera versión de este post sugería git push origin +nombre-de-la-branch. El + hace lo mismo que --force: sobrescribe el remoto con tu versión, sin mirar lo que hay allí. Hice la prueba: una compañera subió un commit a la branch mientras yo reescribía la mía. Con +main, el push pasó, y su commit desapareció del remoto:
$ git push origin +main
+ c0a4ca7...db2256b main -> main (forced update)Con --force-with-lease, el mismo push fue rechazado:
$ git push --force-with-lease origin main
! [rejected] main -> main (stale info)
error: failed to push some refs to '../origin.git'--force-with-lease solo sobrescribe si el remoto sigue igual a la última versión que viste (tu origin/main). Si alguien subió algo mientras tanto, rechaza, y tú haces git fetch, traes el commit de esa persona e intentas de nuevo.
Un cuidado: si ejecutas git fetch justo antes, tu origin/main ya está actualizada, y el lease deja pasar el push aunque no hayas incorporado el commit de esa persona. Para cerrar ese hueco existe --force-if-includes, que comprueba que lo que está en el remoto también esté en tu branch. Lo probé: después de un git fetch, --force-with-lease solo pasó por encima del commit nuevo de la compañera, y con --force-if-includes el push fue rechazado:
$ git push --force-with-lease --force-if-includes origin main
! [rejected] main -> main (remote ref updated since checkout)Vale la pena un alias para no escribir esto cada vez:
git config --global alias.pushf "push --force-with-lease --force-if-includes"
git pushfY la regla de siempre: push forzado en tu branch, todo bien. En la main compartida, combínalo antes con el equipo (o deja la main protegida en GitHub).
git reflog: el deshacer de Git#
¿Un rebase salió mal? ¿Un reset --hard en el lugar equivocado? Calma. Casi nada se pierde de verdad en Git. git reflog guarda cada lugar por donde pasó tu HEAD, incluso commits que ya no aparecen en git log:
$ git reflog -6
9eadb5e HEAD@{0}: rebase (finish): returning to refs/heads/main
9eadb5e HEAD@{1}: commit (amend): add z
3a8f3fa HEAD@{2}: rebase (pick): add z
f7db88b HEAD@{3}: commit (amend): feat: add the profile page
8d7de9d HEAD@{4}: rebase (start): checkout HEAD~2
fba2c8f HEAD@{5}: rebase (finish): returning to refs/heads/mainAsí deshice el rebase que cambió el autor del commit de mi compañera. HEAD@{5} era el estado anterior, entonces:
git reset --hard HEAD@{5}Y todo volvió a como estaba. Antes de cualquier operación que te dé miedo, también puedes crear una branch de seguridad, que no cuesta nada:
git branch backup/before-rebaseSi algo sale mal, la branch está ahí, apuntando al commit de antes.
El reflog es local y no es eterno: por defecto, las entradas de commits que no están en ninguna branch caducan a los 30 días. Y un cambio que nunca tuvo commit ni se guardó en el stash, el reflog no lo puede salvar.
Resumen para pegar al lado del monitor#
| Quiero... | Comando |
|---|---|
| Guardar lo que no tiene commit y limpiar el directorio | git stash push -u -m "name" |
| Traerlo de vuelta del cajón | git stash pop |
| Renombrar un archivo | git mv old new |
| Ver el historial de un archivo renombrado | git log --follow -- file |
| Agregar un archivo olvidado al último commit | git add file && git commit --amend --no-edit |
| Ver qué llegó al remoto, sin tocar nada | git fetch && git log main..origin/main |
| Actualizar mi branch en línea recta | git rebase origin/main |
| Juntar o editar commits antes del PR | git rebase -i origin/main |
| Subir historial reescrito sin borrar el de nadie | git push --force-with-lease |
| Deshacer un desastre | git reflog y git reset --hard HEAD@{n} |
Conclusión#
¿Ves que no es un monstruo? Cuando ves los cinco lugares (directorio, stash, index, repositorio local y remoto), cada comando es solo una flecha entre ellos. Y con reflog en el bolsillo, equivocarse deja de dar miedo, porque casi todo tiene vuelta atrás.
¿Quieres practicar sin riesgo? Crea una carpeta, ejecuta git init y haz todos los ejemplos de este post ahí. Así probé cada comando de aquí.
Referencias#
Sigue leyendo

Infra12 min de lectura
Datadog desde cero: cómo integrarlo y cómo leer el panel

Infra15 min de lectura
Cómo ahorrar tokens en Claude Code con rtk y graphify

Infra13 min de lectura
Cómo borrar un disco duro o SSD antes de venderlo