# Trabajar sin pisarse

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

> **Respuesta corta**
>
> <strong><code>fetch</code> trae y no toca nada; <code>pull</code> trae y mezcla.</strong> Esa es toda la diferencia, y por eso <code>fetch</code> es seguro siempre. La rutina que evita casi todos los líos son tres costumbres: bajar antes de empezar el día, trabajar en tu propia rama y subir seguido en vez de guardar una semana de trabajo sin publicar.

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

Trabajar sola con Git es fácil. Los problemas empiezan cuando hay dos personas tocando el mismo proyecto, y casi todos vienen de lo mismo: alguien trabajó cuatro días sin bajar lo de los demás 🙃

![Cuando GitHub tiene commits nuevos hay dos caminos: git fetch los baja sin tocar tu trabajo y te deja mirarlos antes de mezclar con git merge, y git pull los baja y los mezcla de una vez. Una nota recuerda que pull es fetch más merge.](https://missyera.com/static/diagramas/webp/git-22-fetch-y-pull.webp)

*pull es fetch y merge en un solo comando, y por eso a veces sorprende. Con fetch primero ves qué viene antes de dejarlo entrar en tu trabajo.*

## Fetch y pull, que no son sinónimos

|  | `git fetch` | `git pull` |
|---|---|---|
| Trae lo de allá | Sí | Sí |
| Toca tus archivos | No | Sí |
| Puede dar conflicto | No | Sí |
| Cuándo lo uso | Para mirar antes de decidir | Cuando quiero ponerme al día |

En una frase: **`pull` es `fetch` más `merge`**. Y como el merge es la parte que puede doler, `fetch` primero te deja mirar sin compromiso 👀

## Mirar antes de mezclar

Montamos un proyecto con dos personas trabajando:

```bash
mkdir equipo
cd equipo
git init -q
printf 'ciudad,monto\nLima,1200\n' > ventas.csv
git add ventas.csv
git commit -q -m "Primeras ventas de Lima"
cd ..
git clone -q --bare equipo servidor.git
cd equipo
git remote add origin ../servidor.git
git push -q -u origin main
cd ..
git clone -q servidor.git compañera
cd compañera
printf 'canal,monto\nBodegas,4200\n' > canales.csv
git add canales.csv
git commit -q -m "Entra el reporte por canal"
git push -q origin main
cd ../equipo
git fetch -q origin
git status --short --branch
```

```text
## main...origin/main [behind 1]
```

Ese `behind 1` es la información que da `fetch`: *"allá hay un commit que tú no tienes"*. Tus archivos siguen intactos.

```bash
git log --oneline HEAD..origin/main
git diff --stat HEAD origin/main
```

```text
b24b9ec Entra el reporte por canal
 canales.csv | 2 ++
 1 file changed, 2 insertions(+)
```

Ahora sabes exactamente qué te vas a traer antes de traértelo. Esto es lo que yo hago siempre antes de un pull en un proyecto con gente 🔍

## Y ahora sí, ponerse al día

```bash
git merge -q origin/main
ls
git log --oneline
```

```text
canales.csv
ventas.csv
b24b9ec Entra el reporte por canal
54da6e2 Primeras ventas de Lima
```

Eso, `fetch` y luego `merge`, es literalmente lo mismo que hace `git pull`. Con la ventaja de que miraste en medio.

## La rutina de cada mañana

Tres líneas, y son las que evitan casi todo:

```bash
git switch -q main
git pull -q --no-rebase origin main
git switch -q -c reporte-por-ciudad
git status --short --branch
```

```text
## reporte-por-ciudad
```

Ponerte al día, y recién ahí crear tu rama del día. Si empiezas a trabajar sin bajar, tu rama nace de una versión vieja y el conflicto está garantizado para el viernes 📅

## Cuando el pull se niega

Este mensaje asusta y es de los buenos:

```bash
git switch -q main
printf 'ciudad,monto\nLima,1200\nArequipa,890\nCusco,760\nTrujillo,1450\nPiura,980\n' > ventas.csv
git add ventas.csv
git commit -q -m "Entra el resto de ciudades"
git push -q origin main
cd ../compañera
git pull -q --no-rebase origin main
sed -i 's/Lima,1200/Lima,1290/' ventas.csv
git add ventas.csv
git commit -q -m "Se corrige el monto de Lima"
git push -q origin main
cd ../equipo
printf 'Chiclayo,1120\n' >> ventas.csv
git pull --no-rebase origin main
```

```
From ../servidor
 * branch            main       -> FETCH_HEAD
   50d9fc5..dde8c21  main       -> origin/main
error: Your local changes to the following files would be overwritten by merge:
	ventas.csv
Please commit your changes or stash them before you merge.
Aborting
Updating 50d9fc5..dde8c21
```

Git no pisó tu trabajo. Te está diciendo *"tienes cambios sin guardar en un archivo que voy a tocar, decide tú"*. Las dos salidas son de capítulos anteriores: commit, o cajón con 8 🧰

```bash
git stash push -q -m "Chiclayo a medias"
git pull -q --no-rebase origin main
git stash pop
cat ventas.csv
```

```text
Auto-merging ventas.csv
On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   ventas.csv

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (9e5acf3cd86de1d0474f838c2ddca052e9a1e259)
ciudad,monto
Lima,1290
Arequipa,890
Cusco,760
Trujillo,1450
Piura,980
Chiclayo,1120
```

El monto corregido de Lima entró y Chiclayo volvió encima. Nadie perdió nada 🤝

La trampa

Llevas la mañana con el reporte de canales a medias. Antes de almorzar traes lo que subió el equipo.

```
$ git status --short
 M canales.csv

$ git pull
error: Your local changes to the following files would be overwritten by merge:
	canales.csv
Please commit your changes or stash them before you merge.
Aborting
```

**Qué está mal**

Git te frenó, y menos mal 🛑

Esto **no** es un error: es Git negándose a pisar tres horas de tu trabajo con lo que viene de fuera. Si no existiera esa negativa, el `pull` se llevaría tus cambios sin avisar.

Hay dos salidas y las dos son de un capítulo anterior: hacer un commit aunque esté a medias, o mandarlo al cajón con `git stash`, que es 8.

Lo que no hay que hacer es lo que hace mucha gente: borrar el archivo para que el pull "pase". Eso no resuelve el conflicto, lo tapa tirando tu trabajo.

## Comprueba que se entendió

Comprueba que lo tienes

Quieres ver qué subió el equipo sin que te cambie nada todavía. ¿Qué comando usas?

- `git fetch`
- `git pull`
- `git status`
- `git log`

## Ejercicios

**1. Monta un proyecto con dos personas**

Un repositorio, un servidor y dos copias.

```bash
cd ..
mkdir tienda
cd tienda
git init -q
printf 'bodega,ciudad\nBodega Inti,Cusco\n' > bodegas.csv
git add bodegas.csv
git commit -q -m "Catalogo inicial de bodegas"
cd ..
git clone -q --bare tienda tienda-servidor.git
cd tienda
git remote add origin ../tienda-servidor.git
git push -q -u origin main
cd ..
git clone -q tienda-servidor.git tienda-rosa
cd tienda-rosa
git log --oneline
```

```text
a9874ae Catalogo inicial de bodegas
```

Dos copias del mismo proyecto, cada una en su carpeta.

**2. Que la otra persona suba algo**

Desde la segunda copia, agrega un minimarket y súbelo.

```bash
printf 'Minimarket Sol,Trujillo\n' >> bodegas.csv
git add bodegas.csv
git commit -q -m "Entra el minimarket de Trujillo"
git push -q origin main
git log --oneline
```

```text
4cb519a Entra el minimarket de Trujillo
a9874ae Catalogo inicial de bodegas
```

Dos commits allá. La primera copia todavía no lo sabe.

**3. Mira sin mezclar**

Desde la primera copia, trae la información sin tocar tus archivos.

```bash
cd ../tienda
git fetch -q origin
git status --short --branch
cat bodegas.csv
```

```text
## main...origin/main [behind 1]
bodega,ciudad
Bodega Inti,Cusco
```

`behind 1` y tu archivo intacto. Eso es `fetch`.

**4. Averigua qué te vas a traer**

Los commits que están allá y aquí no.

```bash
git log --oneline HEAD..origin/main
git diff --stat HEAD origin/main
```

```text
4cb519a Entra el minimarket de Trujillo
 bodegas.csv | 1 +
 1 file changed, 1 insertion(+)
```

Un commit, un archivo, una línea. Ya sabes a qué atenerte.

**5. Ponte al día**

Ahora sí, mezcla.

```bash
git merge -q origin/main
cat bodegas.csv
git status --short --branch
```

```text
bodega,ciudad
Bodega Inti,Cusco
Minimarket Sol,Trujillo
## main...origin/main
```

Al día. `fetch` más `merge` es `pull`.

**6. Haz la rutina de la mañana**

Bajar, y recién ahí crear tu rama del día.

```bash
git pull -q --no-rebase origin main
git switch -q -c catalogo-de-horeca
git status --short --branch
```

```text
## catalogo-de-horeca
```

Tu rama nace de la versión de hoy, no de la del lunes pasado 📅

**7. Provoca la negativa del pull**

Deja un cambio sin guardar y trata de bajar lo del equipo.

```bash
git switch -q main
cd ../tienda-rosa
git pull -q --no-rebase origin main
sed -i 's/Bodega Inti,Cusco/Bodega Inti,Arequipa/' bodegas.csv
git add bodegas.csv
git commit -q -m "La bodega Inti se mudo a Arequipa"
git push -q origin main
cd ../tienda
printf 'Mayorista Norte,Piura\n' >> bodegas.csv
git pull --no-rebase origin main
```

```
From ../tienda-servidor
 * branch            main       -> FETCH_HEAD
   4cb519a..45f0337  main       -> origin/main
error: Your local changes to the following files would be overwritten by merge:
	bodegas.csv
Please commit your changes or stash them before you merge.
Aborting
Updating 4cb519a..45f0337
```

Git te frena en vez de pisarte. Guarda o manda al cajón, y vuelve a intentarlo 🛑

## Lo que te llevas

**Fetch mira, pull mezcla. Baja antes de empezar y trabaja en tu rama.**

## Seguir leyendo

- Anterior: [Pedir ayuda sin quedarte esperando](https://missyera.com/guias/git-desde-cero/issues.md)
- Siguiente: [Revisar el trabajo de otra persona](https://missyera.com/guias/git-desde-cero/revisar-el-trabajo-ajeno.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/trabajar-sin-pisarse/
- Índice de todas las páginas en texto: https://missyera.com/llms-index.txt
