Cómo Eliminar el Último Commit en Git: Guía Completa

La pesadilla que todos hemos vivido

¿Alguna vez has hecho un commit y al segundo siguiente te has dado cuenta de que metiste la pata? Yo sí, y más de una vez. Esa sensación de pánico cuando realizas que acabas de commitear un password, código roto, o simplemente algo que no tenía que estar ahí es horrible.

La buena noticia es que Git no es tan cruel como parece al principio. He pasado años usando Git y puedo decirte que casi siempre hay una forma de arreglar las cosas, incluso cuando sientes que acabas de destruir todo tu proyecto.

Git es genial precisamente porque te permite experimentar sin miedo. Es como tener una máquina del tiempo para tu código, pero eso sí, necesitas saber cómo usarla correctamente.

¿Qué es exactamente un commit?

Antes de meternos en faena, déjame explicarte qué es realmente un commit de manera simple. Un commit es como una foto instantánea de tu código en un momento específico. Es tu forma de decirle a Git: "Oye, guarda este estado porque está bien así".

Cada commit tiene:

• Un identificador único (hash SHA-1)
• Un mensaje descriptivo
• Información sobre el autor
• Una referencia al commit anterior (su "padre")
• Los cambios realizados desde el último commit

Lo importante es que todos estos commits forman la historia de tu proyecto. Es como un álbum de fotos, pero de código. Y la mejor parte es que puedes viajar hacia atrás en el tiempo cuando algo sale mal.

¿Por qué querríamos eliminar un commit?

En mi experiencia, hay varias situaciones típicas donde necesitas deshacer un commit:

El clásico "ups, se me fue el password"

Esto me ha pasado más veces de las que me gustaría admitir. Commiteas algo con una API key, un password, o información personal que definitivamente no debería estar en tu repo.

Código que no funciona

A veces commiteas demasiado rápido y después te das cuenta de que el código está roto. Es mejor eliminarlo que tener un commit inútil en tu historial.

Te equivocaste de rama

¿Cuántas veces has commiteado en main cuando querías hacerlo en tu rama de desarrollo? Es un clásico.

Mensaje horrible

Escribiste un mensaje de commit que no tiene nada que ver o tiene errores que te dan vergüenza ajena.

Commit incompleto

Te faltó agregar archivos importantes y el commit queda a medias.

Sea cual sea tu caso, Git tiene soluciones. Vamos a verlas.

Comandos básicos que necesitas conocer

Antes de meternos con los comandos "peligrosos", asegúrate de dominar estos básicos:

Ver el historial de commits

Para ver los commits previos y sus identificadores:

git log

Para una versión más compacta:

git log --oneline

Examinar el estado actual

Para ver qué archivos han sido modificados y su estado:

git status

Añadir cambios al área de preparación

Para preparar archivos para el próximo commit:

git add nombre-del-archivo

Para añadir todos los cambios:

git add .

Crear un nuevo commit

Para guardar los cambios preparados en un nuevo commit:

git commit -m "Mensaje descriptivo sobre los cambios que hiciste"

Estos comandos son tu pan de cada día con Git. Si ya los dominas, perfecto. Si no, practica un poco antes de seguir.

La solución: eliminar el último commit

Ahora viene lo bueno. Dependiendo de tu situación, hay varias formas de eliminar ese commit problemático.

Método 1: Git reset (para commits locales)

Si el commit que quieres eliminar existe solo en tu máquina y no lo has compartido con nadie (no has hecho push), git reset es tu mejor amigo:

git reset --hard HEAD~1

Este comando mueve la referencia HEAD un commit hacia atrás (HEAD~1) y descarta todos los cambios (--hard).

Ojo: Este método elimina permanentemente los cambios realizados en ese commit. Si quieres preservar esos cambios, usa --soft en lugar de --hard:

git reset --soft HEAD~1

Con --soft, los cambios del commit eliminado se mantienen en tu área de trabajo, permitiéndote modificarlos y crear un nuevo commit.

Por ejemplo, si te faltó agregar un archivo al commit, puedes usar este comando para regresar a tu último commit y agregar el archivo.

Método 2: Git rebase (para reorganizar commits)

Si necesitas editar varios commits o eliminar uno en el medio, puedes usar rebase interactivo:

git rebase -i HEAD~n

Donde n es el número de commits que quieres revisar. Esto abrirá un editor de texto donde puedes eliminar, reordenar o combinar commits.

Deshacer sin perder el trabajo

Una de las cosas que más me gusta de Git es que puedes deshacer commits pero mantener tu trabajo. Es perfecto para esos casos donde el commit está mal pero el código está bien.

Reset suave (mi favorito)

git reset --soft HEAD~1

Este comando:

1. Elimina el último commit del historial
2. Mantiene todos los cambios en el área de preparación (staged)
3. Te permite modificar los archivos y hacer un nuevo commit

Es útil cuando:

• El commit tenía errores menores
• Olvidaste incluir algunos archivos
• Quieres mejorar el mensaje del commit

Ejemplo que uso todo el tiempo

Imagina que has realizado un commit pero olvidaste añadir un archivo importante:

# Eliminar el último commit pero mantener los cambios
git reset --soft HEAD~1

# Añadir el archivo olvidado
git add archivo-olvidado.js

# Crear un nuevo commit con todos los cambios
git commit -m "Mensaje mejorado que incluye todo"

Cuando eliminar no es la mejor opción

A veces, especialmente si ya compartiste tu commit con otros, eliminar no es la mejor idea. Git tiene alternativas más seguras:

Crear un commit de corrección

Si ya has compartido tu commit con otros, la mejor práctica es crear un nuevo commit que corrija los errores:

# Realiza los cambios necesarios
git add .
git commit -m "Corrige errores en el commit anterior"

Usar git revert (súper seguro)

El comando revert crea un nuevo commit que deshace los cambios de un commit anterior:

git revert HEAD

Esto es seguro incluso si ya has publicado el commit, ya que no altera el historial existente sino que añade un nuevo commit.

Enmendar el último commit

Si solo necesitas modificar ligeramente el último commit:

git add .
git commit --amend

Esto te permitirá cambiar el mensaje del commit y/o añadir cambios adicionales al último commit.

Mis consejos para evitar estos problemas

Después de años cometiendo errores con Git, he aprendido algunas cosas que me ayudan a evitar problemas:

Revisar antes de commitear

Siempre uso git diff y git status para revisar los cambios antes de confirmarlos:

git diff --staged

Hacer commits pequeños

Hago commits pequeños y enfocados en un solo cambio lógico. Es mucho más fácil deshacer algo específico que un commit gigante con 20 cambios diferentes.

Usar ramas para experimentar

Creo ramas separadas para cosas experimentales:

git checkout -b experimento

Si algo sale mal, simplemente descarto la rama sin drama.

Configurar herramientas de pre-commit

Uso herramientas como husky o pre-commit para verificar automáticamente antes de cada commit:

// En package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged && npm test"
    }
  }
}

Crear alias útiles

Tengo configurados algunos alias para comandos que uso frecuentemente:

git config --global alias.oops 'reset --soft HEAD~1'

Así puedo usar git oops para deshacer el último commit manteniendo los cambios.

Herramientas que te van a salvar la vida

Si eres más visual como yo, estas herramientas pueden ayudarte muchísimo:

Interfaces gráficas

• GitKraken: Mi interfaz visual favorita. Te muestra claramente qué está pasando con tu repositorio.
• SourceTree: Gratis y muy buena para visualizar el historial de cambios.
• VS Code con GitLens: Si usas VS Code, esta extensión es imprescindible.

Recursos para aprender más

• Git - La guía sencilla: Perfecta para empezar.
• Learn Git Branching: Tutorial interactivo súper útil.
• Pro Git Book: El libro oficial, y es gratis.

Mi reflexión final

Git puede parecer intimidante al principio, pero una vez que entiendes cómo funciona, se convierte en tu mejor aliado. He cometido prácticamente todos los errores posibles con Git, y créeme, siempre hay una forma de solucionarlos.

Lo que he aprendido después de años usando Git:

1. Piensa antes de hacer push: Una vez que compartes tus commits, es mejor crear commits correctivos que reescribir la historia.

2. Los buenos mensajes de commit son oro: Tu yo del futuro te lo agradecerá.

3. Usa ramas sin miedo: En Git las ramas son baratas, úsalas para todo.

4. Practica en repos de prueba: Antes de hacer algo que no dominas en un proyecto importante, pruébalo en un repo que no importe.

5. No entres en pánico: En Git, casi siempre hay una forma de recuperarse de cualquier desastre.

Lo importante es recordar que Git está ahí para ayudarte, no para complicarte la vida. Una vez que le coges el truco, programar se vuelve mucho más relajado porque sabes que siempre puedes volver atrás si algo sale mal.