# Por qué existe Git

URL canónica: https://missyera.com/guias/git-desde-cero/por-que-existe-git/
Última actualización: 2026-11-17
Autora: Gera Flores (Miss Yera)

> **Respuesta corta**
>
> Git es un programa que guarda las versiones de una carpeta por ti, y te deja volver a cualquiera de ellas. Lo que a mí me costó entender es que no guarda archivos sueltos: guarda <strong>momentos</strong> de la carpeta entera, y a cada momento le pones un nombre. Eso es todo el invento, y por eso reemplaza a los quince archivos que terminan en ESTE_SI 🗂️

Capítulo 1 de 33 del libro [Git desde cero](https://missyera.com/guias/git-desde-cero.md).

## La carpeta que todas tenemos

Abre la carpeta donde guardas los informes del trabajo. Yo espero.

Si se parece a la mía, ahí dentro hay algo así:

```bash
mkdir -p informes
cd informes
touch "informe.docx" "informe_v2.docx" "informe_final.docx" \
      "informe_final_v2.docx" "informe_final_ESTE_SI.docx" \
      "informe_final_ESTE_SI_corregido.docx"
ls
```

```text
informe.docx
informe_final.docx
informe_final_ESTE_SI.docx
informe_final_ESTE_SI_corregido.docx
informe_final_v2.docx
informe_v2.docx
```

Seis archivos que son el mismo archivo.

```bash
ls -1 | wc -l
```

```text
6
```

Y ahora contesta rápido, sin abrirlos: **¿cuál es el bueno?**

Ese medio segundo de duda es el problema entero. No es que seas desordenada. Es que una carpeta no sabe contar historias: solo sabe tener archivos, y el nombre del archivo es el único sitio donde puedes escribir cuándo lo hiciste y por qué 📋

Y encima el nombre miente. `informe_final_ESTE_SI` era el bueno el martes. El jueves ya no.

## Qué hace Git con eso

Git le pone a la carpeta una memoria. En vez de seis archivos, tienes uno solo, y aparte una lista de todos los momentos por los que pasó ese archivo, cada uno con su fecha y con una frase tuya explicando qué cambió.

Se ve mejor haciéndolo. Voy a armar la carpeta de las ventas de la tienda, que es la que vamos a usar en todo el libro.

```bash
cd ..
mkdir ventas-miss-yera
cd ventas-miss-yera
git init
```

```text
Initialized empty Git repository in /home/miss-yera/ventas-miss-yera/.git/
```

Ya está. Esa carpeta ahora tiene memoria.

Le meto el primer archivo, las ventas de Lima:

```bash
printf 'ciudad,monto\nLima,1200\n' > ventas.csv
cat ventas.csv
```

```text
ciudad,monto
Lima,1200
```

## El primer momento, y el primer tropiezo

Guardar un momento se llama **hacer un commit**. Se dice así en todos lados y en español no tiene traducción buena, así que nos quedamos con commit. Lo pido:

```bash
git commit -m "Ventas de Lima"
```

```
On branch main

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	ventas.csv

nothing added to commit but untracked files present (use "git add" to track)
```

No lo hizo. Y fíjate en la última línea, porque es de las pocas veces que un programa te dice exactamente qué te falta: *nothing added to commit*, nada agregado para guardar.

Git no guarda lo que encuentra. Guarda lo que tú le señalas. Es a propósito: en la carpeta hay archivos que no quieres guardar nunca, y ya volveremos sobre eso. Así que primero señalo el archivo y después guardo el momento:

```bash
git add ventas.csv
git commit -m "Primeras ventas de Lima"
```

```text
[main (root-commit) 54da6e2] Primeras ventas de Lima
 1 file changed, 2 insertions(+)
 create mode 100644 ventas.csv
```

Eso de `54da6e2` es el nombre del momento. Se llama hash y sale de mezclar lo que guardaste con quién eres tú y qué hora era, así que **a ti te va a salir otro**. No te asustes cuando pase: es lo normal, y en el capítulo 3 te cuento por qué.

## Y ahora la parte que enamora

Llegan las ventas de Arequipa. Cambio el archivo y guardo otro momento:

```bash
printf 'Arequipa,890\n' >> ventas.csv
git add ventas.csv
git commit -m "Se suman las ventas de Arequipa"
```

```text
[main 77fadab] Se suman las ventas de Arequipa
 1 file changed, 1 insertion(+)
```

Un solo `ventas.csv` en la carpeta. Cero archivos con ESTE_SI. Y sin embargo:

```bash
git log --oneline
```

```text
77fadab Se suman las ventas de Arequipa
54da6e2 Primeras ventas de Lima
```

Ahí está la historia. Dos momentos, el último arriba, cada uno con la frase que yo escribí. Eso es lo que la carpeta no sabía hacer.

Y puedo preguntarle qué cambió exactamente entre uno y otro:

```bash
git diff HEAD~1 HEAD -- ventas.csv
```

```text
diff --git a/ventas.csv b/ventas.csv
index b5256c1..0c80877 100644
--- a/ventas.csv
+++ b/ventas.csv
@@ -1,2 +1,3 @@
 ciudad,monto
 Lima,1200
+Arequipa,890
```

La línea con el `+` delante es lo que entró. Nadie tuvo que acordarse, ni comparar dos Excel abiertos al lado, ni preguntar por WhatsApp cuál era el bueno 🙌

## Lo que Git no es

Tres confusiones que veo siempre, y mejor sacarlas del medio ahora.

**Git no es GitHub.** Git es el programa que corre en tu computadora y no necesita internet. GitHub es una página donde puedes dejar una copia de tu repositorio para compartirlo. Puedes usar Git toda tu vida sin GitHub. Le dedicamos un capítulo entero más adelante porque es donde más gente se pierde.

**Git no es solo para código.** Funciona con cualquier archivo de texto: tus consultas SQL, tus notas, un CSV de ventas, la propuesta de un cliente. Con un Word o un PDF funciona a medias, porque Git sabe decirte qué línea cambió en un texto y no sabe hacerlo dentro de un binario.

**Git no es una copia de seguridad.** Guarda la historia en la misma computadora. Si se te malogra el disco, se va todo. Para eso está la copia en GitHub, que es otra cosa.

## Por qué esto te toca ahora

Durante veinte años Git fue cosa de programadores. Dejó de serlo el día que las herramientas de IA se mudaron a GitHub.

Hoy quieres probar una skill de Claude, un agente que alguien publicó o el proyecto que viste en LinkedIn, y todos están en un repositorio. Sin Git te quedas mirando desde afuera, con el botón verde que dice Code y sin saber qué hacer con él.

Ese es el libro. No vas a terminar siendo programadora: vas a terminar pudiendo bajar lo que encuentres, entenderlo, cambiarlo y publicar lo tuyo.

La trampa

Creas el repositorio de la tienda, todo va bien, y a la semana notas que cualquier cosa que guardas en el escritorio aparece como cambio pendiente.

```
$ cd ~
$ git init
$ git status

On branch main
Untracked files:
	 Descargas/
	 Documentos/
	 Escritorio/
	 ... (14.203 archivos más)
```

**Qué está mal**

El `git init` se corrió en tu carpeta personal, no en la del proyecto 📁

Git no se queja: convierte en repositorio la carpeta donde estás parada, sea cual sea, y a partir de ahí vigila todo lo que hay debajo. Tus fotos, tus descargas y el Excel de la contadora.

Por eso el orden del capítulo 3 es crear la carpeta, **entrar** y recién ahí inicializar. Los tres pasos en ese orden, siempre.

Si ya te pasó, no hay que reinstalar nada: se borra la carpeta oculta `.git` que quedó en tu casa y listo, todo vuelve a ser una carpeta normal.

## Comprueba que se entendió

Comprueba que lo tienes

¿Qué guarda Git cuando haces un commit?

- Los archivos que cambiaron desde el commit anterior
- Un momento de la carpeta entera, con la frase que tú escribiste
- Una copia de seguridad de tu computadora
- El archivo con un número de versión al final del nombre

## Ejercicios

Los ejercicios son la mitad del libro. Intenta antes de abrir.

**1. Cuenta tus propios ESTE_SI**

Antes de seguir, abre la carpeta donde guardas tu trabajo y cuenta cuántos archivos son en realidad el mismo archivo en versiones distintas. No hace falta comando, hace falta honestidad.

Yo conté seis del mismo informe y dos de la misma propuesta para un cliente. Ocho archivos que eran dos. Ese número es tu motivo para terminar el libro 📊

**2. Pregúntale a Git dónde estás parada**

Dentro de la carpeta de ventas, pide el estado. Es el comando que más vas a escribir en tu vida.

```bash
git status
```

```text
On branch main
nothing to commit, working tree clean
```

*Working tree clean* significa que no hay nada pendiente: todo lo que está en la carpeta ya está guardado en la historia. Cuando algo te dé miedo, este comando es el primero.

**3. Un tercer momento, con Trujillo**

Agrega las ventas de Trujillo por 1.450 soles y guarda el momento con una frase que explique qué hiciste.

```bash
printf 'Trujillo,1450\n' >> ventas.csv
git add ventas.csv
git commit -m "Se suman las ventas de Trujillo"
```

```text
[main 7fae607] Se suman las ventas de Trujillo
 1 file changed, 1 insertion(+)
```

Fíjate que el mensaje dice qué pasó, no dice "cambios". Dentro de seis meses vas a agradecerte cada frase que escribiste bien.

**4. Mira la historia completa**

Pide el log corto y comprueba que están los tres momentos, el más reciente arriba.

```bash
git log --oneline
```

```text
7fae607 Se suman las ventas de Trujillo
77fadab Se suman las ventas de Arequipa
54da6e2 Primeras ventas de Lima
```

Tres líneas, tres decisiones tuyas. Y el archivo sigue siendo uno solo.

**5. Cuántas líneas tiene el archivo de verdad**

Comprueba que en la carpeta hay un solo CSV y que dentro están las cuatro líneas: la cabecera y las tres ciudades.

```bash
ls
cat ventas.csv
```

```text
ventas.csv
ciudad,monto
Lima,1200
Arequipa,890
Trujillo,1450
```

Esto es lo que quería que vieras: **una carpeta limpia con una historia larga detrás**. Antes tenías la historia desparramada en los nombres de los archivos; ahora está guardada donde se puede consultar.

**6. Vuelve a ver Lima sola, sin romper nada**

Pídele a Git cómo se veía `ventas.csv` en el primer momento, cuando solo estaba Lima. Ojo: mirar no es volver.

```bash
git show HEAD~2:ventas.csv
```

```text
ciudad,monto
Lima,1200
```

Ahí está el archivo como era al principio, y en tu carpeta sigue estando la versión con las tres ciudades. Puedes mirar el pasado sin mudarte a él 🕰️

El `HEAD~2` significa "dos momentos antes del actual". Es la primera forma de moverte por la historia y no va a ser la última.

**7. El commit que no se hizo**

Crea un archivo con los datos del cliente de una bodega y trata de guardarlo sin señalarlo primero. Tiene que fallar.

```bash
printf 'bodega,contacto\nMinimarket Lima,999888777\n' > clientes.csv
git commit -m "Datos del cliente"
```

```
On branch main
Untracked files:
  (use "git add <file>..." to include in what will be committed)
	clientes.csv

nothing added to commit but untracked files present (use "git add" to track)
```

El mismo mensaje del principio del capítulo, y ahora ya sabes leerlo. Git no guarda lo que encuentra, guarda lo que le señalas 👆

Que este error te salga tantas veces al principio es normal, y es bueno: es la barrera que impide que subas sin querer el archivo con las claves.

## Lo que te llevas

**Una carpeta no sabe contar historias. Git le presta la memoria.**

## Preguntas frecuentes

### ¿Qué es Git?

Un programa que guarda la historia de tus archivos: qué cambió, cuándo y quién. Es lo que te deja volver a como estaba el martes sin tener carpetas llamadas version_final_2.

### ¿Qué es el control de versiones?

Llevar registro de cada cambio en vez de sobrescribir. Git es el que se usa hoy en casi todas partes.

### ¿Para qué sirve Git si trabajo sola?

Para poder deshacer sin miedo y para saber qué hiciste hace tres semanas. Trabajar en equipo es la segunda razón, no la primera.

### ¿Cuál es la diferencia entre Git y GitHub?

Git es el programa y vive en tu computadora. GitHub es un sitio web donde se guardan copias de repositorios de Git. Puedes usar Git sin GitHub perfectamente.

## Seguir leyendo

- Siguiente: [Dejar tu máquina lista](https://missyera.com/guias/git-desde-cero/instalar-y-configurar.md)

## Contacto

- Diagnóstico de 30 minutos con Miss Yera: https://calendly.com/soymissyera/reunion-con-yera
- Correo: hola@missyera.com
- Esta página en HTML: https://missyera.com/guias/git-desde-cero/por-que-existe-git/
- Índice de todas las páginas en texto: https://missyera.com/llms-index.txt
