Cómo eliminar archivos de repositorios Git sin romper tu proyecto

Eliminar archivos en Git no siempre es tan sencillo como parece. Puedes borrar un archivo en tu sistema, pero eso no significa que desaparezca del repositorio. Puede seguir existiendo en el historial o, peor aún, acabar en un commit por accidente, como un archivo de configuración o una clave de API.

En esta guía aprenderás a eliminar archivos en Git. Empezaremos con comandos básicos como git rm y luego veremos métodos más avanzados como limpiar archivos no rastreados y editar tu historial de commits.

Requisitos previos

Antes de eliminar archivos con Git, asegúrate de que todo está listo.

Primero, comprueba si Git está instalado. Abre la terminal y ejecuta:

git --version

Si ves un número de versión, puedes continuar. 

Si ves un número de versión, puedes continuar.

También puedes instalar una GUI de Git como GitHub Desktop, Sourcetree o GitKraken si prefieres una interfaz visual. Pero en esta guía usaré la línea de comandos (Git Bash).

Asegúrate de tener permiso para hacer cambios en el repositorio, especialmente si formas parte de un equipo o trabajas con un remoto como GitHub o GitLab.

Nota: Algunas acciones de borrado no se pueden deshacer. Así que conviene hacer una copia de seguridad del proyecto o, al menos, revisar bien el estado del repo antes de ejecutar comandos que eliminen archivos.

Cuando lo tengas, empecemos.

Eliminación básica de archivos en Git

Hay varias formas de eliminar archivos en Git, según lo que quieras hacer. Veamos algunas opciones comunes:

Usar git rm

El comando git rm elimina archivos de tu repositorio Git. Al ejecutarlo pasan dos cosas:

• Git elimina el archivo del directorio de trabajo
• Prepara ese cambio para el próximo commit (lo añade al staging)

Pero Git no solo borra el archivo. Registra la eliminación en tu historial. Cuando haces commit, el archivo se elimina oficialmente del proyecto.

git rm file1.txt

Puedes eliminar un archivo, varios o un grupo usando comodines. 

Por ejemplo, para eliminar todos los archivos de log:

git rm *.log

Esto le dice a Git que elimine todos los archivos de la carpeta que terminen en .log. Puedes confirmar el cambio con:

git status

Elimina varios archivos con un solo comando git rm. Imagen del autor.

¿Quieres eliminar todos los archivos dentro de una carpeta pero no la carpeta en sí? Usa:

git rm temp/*

Esto borra todos los archivos dentro de la carpeta temp sin eliminar la carpeta.

Git también añade algunas comprobaciones de seguridad. Si un archivo tiene cambios sin commitear, Git no lo borrará a menos que lo fuerces. Úsalo solo si estás seguro de que puedes descartar esos cambios:

git rm -f

Para eliminar una carpeta completa y todo su contenido, añade la opción -r:

git rm -r testfolder

Esto elimina testfolder y todos los archivos que contiene.

Ahora, para confirmar el cambio, ejecuta:

git commit -m "removed log files”

Opciones clave de git rm

Estas son las opciones más habituales que usarás con git rm:

1. <filename>

Uso básico. Enumera los archivos que quieres eliminar:

git rm file1.txt file2.txt

También puedes usar un comodín para eliminar varios archivos del mismo tipo. Por ejemplo, para borrar todos los .txt:

git rm *.txt

(Aquí, * significa «todos». Coincide con cualquier nombre que termine en .txt.)

2. --cached

Esto elimina el archivo del repositorio pero lo mantiene en tu ordenador. Imagina que añadiste por error un archivo sensible como config.env. No lo quiero en el repo, pero sí en mi máquina. Entonces ejecutaría:

git rm --cached config.env

Aquí, git rm lo borraría del repositorio y del directorio de trabajo. Y --cached deja de rastrearlo en Git (no se subirá), pero lo mantiene físicamente en su sitio.

Para evitar añadirlo de nuevo, añádelo a .gitignore:

echo config.env >> .gitignore

3. -r

Significa recursivo. En lugar de un archivo, elimina recursivamente el directorio y su contenido. Sin esto, Git te dará un error si intentas borrar una carpeta.

git rm -r <folder-name>

Aquí he creado una carpeta llamada testfolder y dos archivos dentro: a.txt y b.txt. Después ejecuto:

git rm -r testfolder

Esto eliminó la carpeta junto con todo su contenido

4. --dry-run

Si no tienes claro qué pasará al eliminar un archivo, usa git rm con la opción --dry-run así:

git rm --dry-run <filename>

Es una forma segura de previsualizar qué se va a eliminar. 

O, si estás limpiando archivos no rastreados y quieres revisar qué se borrará, usa:

git clean -n

Esto solo mostrará lo que el comando eliminaría.

Análisis comparativo de flujos de trabajo

Hay más de una forma de eliminar un archivo en Git. Pueden parecer iguales, pero no se comportan igual.

git rm vs borrado manual

Tomemos un archivo llamado file.txt. Digamos que ya no lo necesito.

Una forma de eliminarlo es borrarlo directamente en el sistema.

En Linux, macOS o Git Bash:

rm file.txt

En Windows (símbolo del sistema): 

del file.txt

Esto borra el archivo de tu carpeta. Pero Git aún no lo sabe. Así que tienes que indicárselo manualmente:

git add file.txt

Esto prepara la eliminación para incluirla en el siguiente commit.

Si borraste varios archivos y no recuerdas todos, puedes ejecutar:

git add -u

Esto prepara todos los archivos rastreados que han cambiado o se han borrado. No incluye archivos no rastreados.

Ahora haz commit del cambio:

git commit -m "Remove file.txt"

Si usas git rm, hace todo en un paso. Borra el archivo y deja el cambio en staging al momento:

git rm file.txtgit commit -m "Remove file.txt"

No hace falta ejecutar git add por separado. Es más limpio y no te olvidas de preparar la eliminación.

En resumen:

• El borrado manual requiere pasos extra para que Git recoja el cambio.
• Si olvidas preparar la eliminación, Git seguirá creyendo que el archivo existe, lo que puede causar confusión en commits o merges.
• git rm es más limpio y seguro cuando eliminas archivos rastreados a propósito.

Restaurar archivos eliminados en Git

¿Y si borras un archivo y luego te das cuenta de que lo necesitas? No pasa nada. Git te da varias formas de recuperarlo según cuándo notes el error.

Si aún no has hecho commit:

Has borrado el archivo pero no has confirmado el cambio. Puedes restaurarlo desde el último commit así: 

git restore file.txt

Esto trae el archivo de nuevo a tu directorio de trabajo desde el último commit.

Si ya hiciste commit del borrado:

También tiene solución. Primero, encuentra el último commit donde el archivo existía:

git log -- file.txt

Revisa el log y copia el hash del commit donde aún estaba. Luego ejecuta:

git checkout <commit hash> -- file.txt

En versiones antiguas de Git podías usar el comando anterior. Restaura un archivo desde un commit concreto, pero también podía cambiar de rama.

Desde Git 2.23, esto se separó en dos comandos más claros:

• git switch (para cambiar de rama)
• git restore (para restaurar archivos)

Si solo quieres restaurar un archivo de un commit, usa:

git restore --source=<commit-hash> --file.txt

Esto extrae el archivo de ese commit y lo devuelve a tu directorio de trabajo.

Si no sabes cuándo se borró el archivo:

Puede que hayas hecho muchos cambios y no recuerdes cuándo desapareció. En ese caso, usa git reflog o registro de referencias: 

git reflog

Muestra un historial completo de tus commits, checkouts, resets, etc.

Pero git reflog es solo local y no funciona en remotos. Si trabajas con un remoto, es mejor usar git log -- file.txt para seguir el historial de ese archivo.

Una vez encuentres el punto donde el archivo existía, restáuralo con git checkout o git restore como antes.

Arreglar archivos desaparecidos en Git

A veces los archivos se borran directamente desde el sistema—ya sea con el explorador de archivos, con rm en la terminal o por accidente. Cuando pasa, Git no lo limpia automáticamente. En su lugar, marca esos archivos como missing y espera a que gestiones correctamente la eliminación.

Veamos cómo proceder paso a paso.

Paso 1: comprueba archivos desaparecidos

Ejecuta esto en la carpeta del proyecto:

git status

Si Git dice que un archivo está eliminado, significa que ya no está en tu sistema, pero el cambio aún no está en staging.

Paso 2: prepara la eliminación 

Para decirle a Git que ponga en staging todos los cambios (incluidos los archivos borrados), ejecuta:

git add -A

• git add -A = prepara todos los cambios (nuevos, modificados, eliminados).
• git add -u = prepara modificados + eliminados, pero no archivos nuevos.

Esto pone en staging todos los cambios: nuevos, modificados y eliminados. Luego haz commit:

git commit -m "Removed missing files"

Es la forma más segura de limpiar porque recoge todos los cambios de una vez.

Paso 3: haz push al remoto 

Si trabajas con un repositorio remoto, sube el commit:

git push origin <branch-name>

Sustituye <branch-name> por tu rama, como main o dev.

Paso 4: alternativa

Imagina que eliminaste un montón de archivos manualmente, ya sea por accidente o al hacer limpieza. Git sigue pensando que existen hasta que le digas lo contrario.

Si no quieres borrarlos uno a uno con git rm, hay una forma más rápida de limpiar.

Ejecuta este comando en la terminal:

git ls-files --deleted -z | xargs -0 git rm

Esto hace lo siguiente:

• git ls-files --deleted lista todos los archivos que Git rastrea pero que ahora faltan.
• xargs -0 git rm pasa esos nombres a git rm y los elimina del índice de Git.

Es muy útil en proyectos grandes cuando quieres limpiar rápido.

Nota: Me aparece este mensaje porque no hay archivos rastreados que actualmente falten en tu disco.

Eliminación avanzada de archivos en Git

Ahora que hemos visto lo básico, pasemos a situaciones más avanzadas en las que eliminar un archivo en Git no es tan simple como ejecutar git rm. Son casos donde hay datos sensibles o hay que limpiar con cuidado archivos no rastreados.

Eliminar datos sensibles de Git

A veces se hace commit por accidente de un archivo con datos privados, como claves de API o contraseñas. Borrarlo de forma normal no sirve. Como Git guarda el historial completo, el archivo seguirá existiendo en commits anteriores.

Para borrarlo por completo, puedes usar el comando git filter-repo: git filter-repo (recomendado)

Es una alternativa más nueva y mejor que filter-branch. Es más rápida, segura y fácil de usar.

Primero, instálalo (necesitarás Python y pip):

pip install git-filter-repo

Luego ejecuta:

git filter-repo --path hide.txt --invert-paths

Esto elimina el archivo hide.txt de todos los commits del historial de tu repo.

Para confirmarlo, ejecuta:

git log --all -- supersecrets.txt

Si el archivo ha desaparecido, añádelo a .gitignore para que no vuelva a rastrearse:

echo hide.txt >> .gitignore

Si trabajas en equipo, limpia el historial reescrito y haz push forzado de los cambios:

git push origin --force --all

Luego avisa a tus compañeros. Tendrán que volver a clonar o resetear sus copias locales para evitar errores.

Limpiar archivos no rastreados con git clean

Vamos por partes:

• Los archivos rastreados están en el historial de Git. Para eliminarlos, usa git rm y luego haz commit.
• Los archivos no rastreados no están en Git. Pueden acumularse y ensuciar tu proyecto.

Para borrar archivos o carpetas no rastreados, usa git clean.

Estas son las opciones más útiles:

git clean -n     # Muestra qué archivos no rastreados se borraríangit clean -nd    # Muestra qué carpetas no rastreadas se borraríangit clean -fd    # Borra todos los archivos y carpetas no rastreados. Es destructivo.

Aquí:

• -n significa solo previsualizar.
• -f significa forzar el borrado.
• -d incluye carpetas en la limpieza.

Nota: git clean no tocará archivos rastreados. Pero sí borrará cualquier cosa no rastreada, incluso archivos que querías conservar. Por eso, usa siempre -n primero para ver qué eliminará.

Eliminar archivos en GitHub y herramientas GUI

Hasta ahora hemos usado la línea de comandos. Pero no todo el mundo trabaja así, y no pasa nada. Muchos desarrolladores usan herramientas visuales o trabajan directamente en GitHub.

Veamos cómo funciona el borrado de archivos en la web de GitHub y en otras herramientas GUI, y cómo se compara con la terminal.

Borrar archivos en el sitio web de GitHub

Si trabajas en la interfaz del navegador de GitHub, puedes borrar archivos sin usar la terminal.

Así funciona en la interfaz de 2025:

1. Abre el archivo que quieres eliminar.
2. Haz clic en los tres puntos de la esquina superior derecha.
3. Elige Delete file en el menú.

GitHub mostrará una caja para el mensaje de commit. Añade un mensaje breve como:

Delete practice.py

También puedes escribir una descripción opcional.

Después, elige cómo guardar el cambio:

• Commit directo a la rama main
• O crea una rama nueva e inicia un pull request (recomendado en trabajo en equipo)

Haz clic en Commit changes y GitHub eliminará el archivo y guardará el borrado como un commit, igual que hace git rm desde la línea de comandos.

Borrar archivos con herramientas GUI de Git

Si usas una GUI como GitHub Desktop, Sourcetree o Tower, el proceso también es sencillo:

1. Elimina el archivo en tu explorador de archivos o dentro de la app.
2. La app mostrará el borrado en «Changes» o «File Status».
3. Revisa, prepara y haz commit del cambio.

Cada herramienta se ve un poco distinta, pero el flujo es similar: ves los cambios de forma visual y haces commit cuando estás listo.

Buenas prácticas según la plataforma

Resumen de cómo funciona el borrado en distintas plataformas y cuándo usar cada una:

• GitHub (Web): Ideal para arreglos rápidos y cambios pequeños. Evítalo para limpiezas grandes o archivos sensibles. 
• Herramientas GUI: Geniales para el día a día. Fácil ver cambios y hacer commit con seguridad. 
• Línea de comandos: Lo más flexible y potente. Mejor para tareas avanzadas como ediciones masivas o cambios de historial. 

Buenas prácticas para eliminar archivos en Git

Eliminar archivos en Git parece simple, pero un paso en falso puede romper tu código. Aquí tienes consejos prácticos que uso para que los borrados sean seguros y controlados, sobre todo en proyectos compartidos o de larga duración.

Verifica siempre antes de borrar

Antes de eliminar un archivo, tómate un minuto para confirmar qué hace:

• Ejecuta git status para ver si está en staging o modificado.
• Usa git log -- <filename> para revisar su historial de commits.

Esta comprobación rápida me ahorra horas de recuperación después.

Haz commits atómicos

Un commit atómico es un commit por cambio lógico.

Por ejemplo, si elimino archivos sin uso, hago commit solo de esas eliminaciones, separado de ediciones de código.

Esto es muy útil porque:

• Depurar es más fácil. Herramientas como git bisect funcionan mejor con commits pequeños y enfocados.
• El historial de commits se mantiene limpio y claro.
• Las revisiones de código van más rápido.

Colabora con cuidado al reescribir historial

Reescribir historial con herramientas como git filter-repo afecta a todo tu equipo. Para evitar el caos:

• Comunica antes de reescribir ramas compartidas.
• Usa git push --force con cuidado: reescribe el historial remoto.
• Indica al equipo que vuelva a clonar o resetear sus repos locales después.

Usa --dry-run antes de comandos destructivos

Antes de ejecutar un comando que borra archivos, pruébalo:

git clean -n

Esto muestra qué se borraría sin eliminar nada. Por qué siempre deberías hacerlo: 

• Evita que borres archivos que realmente quieres conservar.
• Es una red de seguridad, especialmente en proyectos grandes donde un error puede arrasar logs o archivos generados.

Combina git rm --cached con .gitignore

Si haces commit por error de algo que no debería estar en el repo (como un config o logs), arréglalo en dos pasos:

1. Deja de rastrear el archivo:```git rm --cached <filename>

git rm --cached <filename>

Esto le dice a Git que deje de rastrear el archivo pero lo mantiene en tu ordenador.

1. Añádelo a .gitignore:

echo <filename> >> .gitignore

Por qué ayuda:

• Mantiene fuera del repo archivos sensibles o locales (como .env, .log o node_modules).
• Evita «ruido» en el historial de Git.
• Futuros cambios en esos archivos no aparecerán en Git.

Casos límite en Git: staging y carpetas vacías

A veces la eliminación de archivos no sale como esperas. Puedes poner en staging el archivo equivocado o toparte con problemas con carpetas vacías. 

Así gestiono los casos límite más comunes.

Quitar un archivo del staging sin perder tus cambios

Imagina que ejecuto git add . y preparo por accidente un archivo que no quería. No quiero perder mis cambios: solo quiero quitarlo del staging.

Para arreglarlo, ejecuto:

git reset HEAD <filename>

Esto lo saca del staging pero mantiene las ediciones.

Para confirmarlo, uso:

git status

Ahora el archivo debería aparecer como "modified" en lugar de "staged".

Mantener carpetas vacías en el repo

Por defecto, Git ignora las carpetas vacías. Si intentas commitear una carpeta sin archivos, Git la omite.

Pero a veces quiero mantener esa carpeta en el repo, por ejemplo para logs futuros o subidas. La solución habitual es añadir un archivo marcador llamado .gitkeep.

Así se hace:

touch logs/.gitkeepgit add logs/.gitkeepgit commit -m "Keep logs folder in the repo"

Esto hace que la carpeta deje de estar «vacía», así que Git la rastrea.

Nota: .gitkeep no es algo propio de Git. Es solo una convención. Puedes llamarlo como quieras, pero .gitkeep indica a otros para qué sirve.

Solución de problemas al eliminar archivos en Git

Estos son problemas comunes que me he encontrado al borrar archivos en Git y cómo solucionarlos.

El archivo sigue apareciendo en el repositorio remoto

Has borrado el archivo, has hecho commit, pero sigue en el remoto. Puede que te hayas olvidado de hacer push.

Asegúrate de ejecutar:

git push origin <branch-name>

Comprueba también:

• ¿Estás en la rama correcta?
• ¿Tu commit incluyó realmente la eliminación del archivo?

Problemas con submódulos

Los submódulos son repositorios Git dentro de otros repositorios Git. No se comportan como carpetas normales.

Si borras archivos dentro de un submódulo:

• Entra en la carpeta del submódulo
• Haz commit y push de los cambios dentro de ese submódulo

Si eliminas el submódulo por completo:

• Borra la carpeta del submódulo
• Elimina las referencias en .gitmodules y .git/config

Estado HEAD separado (detached)

En Git, HEAD normalmente apunta a la rama actual. Pero a veces apunta a un commit concreto: eso es un HEAD separado.

Ocurre si:

• Haces checkout de un commit por su hash
• Cambias a una etiqueta (tag)
• Haces checkout de una rama remota sin configurarla como de seguimiento

Comprueba tu estado:

git status

Si ves:

HEAD detached at <commit-hash>

No estás en una rama, y cualquier cambio nuevo puede perderse al cambiar.

Cómo puedes arreglarlo: 

Si has hecho cambios y quieres conservarlos, ejecuta:

git checkout -b <new-branch-name>

Esto pone tu trabajo en una nueva rama y lo guarda.

Si ya hiciste commit de los cambios y quieres moverlos a otra rama más tarde, haz esto:

git checkout -b temp-branch          # from detached HEADgit checkout main                    # or another target branchgit merge temp-branch

Si no hiciste cambios y solo quieres salir del estado detached HEAD, ejecuta:

git checkout <branch-name> 

Listo. HEAD vuelve a estar adjunto y todo vuelve a la normalidad.

Errores de permisos o de estado

A veces Git no borrará un archivo, sobre todo en Windows. Puede pasar si:

• El archivo está abierto en otro programa
• Git no tiene permisos para actualizarlo

Cómo solucionarlo:

• Cierra cualquier app que esté usando el archivo
• Reinicia la terminal como administrador (en Windows)

Problemas al hacer merge o rebase

Si ves errores como:

• you are not currently on a branch
• merge conflict

Probablemente estás a mitad de un merge o un rebase.

Para finalizar un rebase tras resolver conflictos:

git rebase --continue

Para cancelar el rebase o el merge por completo:

git reset --merge

Esto devuelve tu repo al estado anterior a empezar el merge.

¿Quieres descartar todos los cambios locales y resetear tu directorio de trabajo? 

Prueba esto:

git restore .

Restaura todos los archivos a su último estado confirmado.

Conclusiones 

Al eliminar archivos en Git, es fácil equivocarse si no prestas atención. Un pequeño error puede provocar problemas mayores: código roto, trabajo perdido o confusión en el equipo. Por eso, tómate un segundo para revisar lo que estás haciendo.

Usa el comando adecuado para cada situación. Si no tienes claro qué hará, pruébalo primero con un dry run. Y si trabajas con otras personas, aseguraos de estar alineados.

Git puede hacer mucho más que borrar archivos. Puedes borrar ramas,  deshacer errores con reset y revert, o ver exactamente qué cambió con git diff. Cuanto más aprendas, más fluido será tu flujo de trabajo.

Ve paso a paso. Así es como se domina esto.