04
Nivel 04 · Experto

Git por dentro

Abre la carpeta .git y mira cómo están hechos los commits, las ramas y los packfiles. Después, las herramientas para trabajar a escala: worktrees, hooks, repos gigantes, submódulos, estrategias de equipo y lo que trae Git 3.0.

Lección 4.1

La carpeta .git por dentro

Todo lo que Git sabe de tu proyecto está en .git, y casi todo son archivos de texto que puedes leer. Cuando lo ves, desaparece la magia: una rama es literalmente un archivo con un hash.

RutaQué es
HEADDónde estás: ref: refs/heads/main, o un hash si HEAD está separado
refs/heads/Tus ramas: un archivo por rama con el hash al que apunta
refs/remotes/, refs/tags/Ramas remotas y tags, igual
objects/Todos los commits, trees y blobs, por hash (sueltos o en packfiles)
indexEl staging, en formato binario
logs/El reflog
config, hooks/Configuración del repo y scripts de hooks
bash
cat .git/HEAD
cat .git/refs/heads/main
git cat-file -t 3f9a2c1      # qué tipo de objeto es
git rev-parse main           # el hash completo de una rama
git count-objects -vH        # cuántos objetos hay y cuánto ocupan
Plumbing y porcelainGit tiene dos capas de comandos. Los de «porcelana» (commit, switch, merge) son para personas. Los de «fontanería» (cat-file, hash-object, update-ref, rev-parse) son las piezas con las que se construyen los anteriores, y son estables para usarlos en scripts.
Lección 4.2

Hashes en cadena

Cada commit incluye el hash de su padre, y el hash de un commit se calcula con todo lo que contiene. Esa cadena tiene una consecuencia enorme: si cambias cualquier cosa de un commit viejo, cambia su hash, y con él el de todos los que vienen después.

Esto explica dos cosas que ya viste. Por qué reescribir historia (amend, rebase) siempre crea commits nuevos: no hay forma de «editar» uno sin cambiar su identidad. Y por qué con el hash del último commit basta para verificar toda la historia: si alguien alterara un byte en el pasado, los hashes dejarían de coincidir. A esta estructura se le llama árbol de Merkle.

En simple

Un hash de commit es la huella de ese commit y de todo su pasado. Dos repositorios con el mismo hash en main tienen exactamente la misma historia.

Lección 4.3

Objetos sueltos y packfiles

Cuando haces commit, cada objeto nuevo se guarda como un archivo comprimido aparte (un objeto «suelto»). Con el tiempo serían miles. Git los junta periódicamente en packfiles: un solo archivo donde las versiones parecidas de un mismo archivo se guardan como diferencias (deltas) de otra.

bash
git count-objects -vH       # objetos sueltos, packs y tamaño
git gc                      # compacta a mano (Git lo hace solo de vez en cuando)
git maintenance start       # programa mantenimiento en segundo plano
git maintenance run --task=gc

Los packfiles también son lo que viaja por la red: fetch, clone y push negocian qué objetos le faltan a cada lado y mandan un pack con solo eso. Por eso clonar un repo con años de historia es más rápido de lo que parece.

Archivos binarios grandesLos deltas funcionan mal con videos, imágenes pesadas o modelos de datos: cada versión pesa casi completa y el repositorio crece sin parar. Para eso existe Git LFS, que guarda esos archivos fuera del repositorio y deja en Git solo un puntero.
Lección 4.4

Worktrees: varias ramas a la vez

Cambiar de rama obliga a guardar o hacer stash de lo que llevas. Un worktree es otra carpeta de trabajo conectada al mismo repositorio, con su propia rama. Puedes tener main en una carpeta, un hotfix en otra y la revisión de un PR en una tercera, todo al mismo tiempo.

bash
git worktree add ../tienda-hotfix -b hotfix/pago   # carpeta nueva con rama nueva
git worktree add ../tienda-review origin/feature-x  # revisar un PR sin tocar tu trabajo
git worktree list
git worktree remove ../tienda-hotfix
git worktree prune                                  # limpia worktrees borrados a mano

Comparten objetos, ramas, stash y configuración: un commit hecho en un worktree aparece en el historial de todos. Lo único que no comparten es lo que está a medias en cada carpeta. Son ideales para dejar trabajando a un agente de IA en una rama mientras tú sigues en otra.

Una rama, un worktreeGit no deja tener la misma rama en dos worktrees a la vez, porque un commit en uno dejaría desactualizado al otro. Si lo necesitas para mirar, usa --detach.
Lección 4.5

Hooks de Git

Un hook es un script que Git ejecuta en un momento concreto: antes de crear un commit, al escribir el mensaje, antes de un push. Si un hook «de antes» termina con error, Git cancela la operación. Sirven para que nadie suba código sin formatear, con tests rotos o con mensajes fuera de formato.

HookCuándo correUso típico
pre-commitAntes de crear el commitFormateo, lint, tests rápidos, buscar secretos
commit-msgCon el mensaje escritoValidar Conventional Commits o un ID de ticket
pre-pushAntes de subirTests más lentos
post-checkout, post-mergeDespués de cambiar de rama o fusionarReinstalar dependencias si cambió el lockfile

Los hooks viven en .git/hooks/, que no se versiona: cada persona tendría que instalarlos. Los equipos los guardan en el repositorio y apuntan Git ahí con core.hooksPath, o usan herramientas como husky, lefthook o pre-commit. Las versiones recientes de Git también permiten declarar hooks directamente en la configuración, e incluso correr varios en paralelo:

bash
git config core.hooksPath .githooks            # hooks versionados en .githooks/

# hooks declarados en la configuración (ver git help hook)
git config set hook.lint.command "npm run lint"
git config set --append hook.lint.event pre-commit
Los hooks locales se pueden saltargit commit --no-verify no ejecuta pre-commit ni commit-msg. Por eso lo importante se valida también en el servidor: reglas de protección de rama y CI (GitHub Actions, GitLab CI) que bloquean el merge si algo falla.
Lección 4.6

Repos gigantes: partial clone y sparse-checkout

En un monorepo con años de historia y cientos de carpetas, clonar todo puede tardar horas y llenar el disco. No necesitas todo: Git puede descargar menos y mostrarte menos.

TécnicaQué recortaCuándo
--filter=blob:none (partial clone)Descarga commits y carpetas, pero el contenido de cada archivo recién cuando lo necesitasDesarrollo diario en repos grandes
sparse-checkoutDeja en disco solo las carpetas que eliges; la historia sigue completaMonorepos donde trabajas en una parte
--depth 1 (shallow clone)Solo los últimos commitsCI y despliegues; mala idea para desarrollar
bash
git clone --filter=blob:none https://github.com/org/monorepo.git
cd monorepo
git sparse-checkout set apps/web services/pagos
git sparse-checkout add docs

scalar clone https://github.com/org/monorepo.git   # todo lo anterior, más mantenimiento

scalar viene incluido con Git y configura un repo grande con las opciones recomendadas: partial clone, sparse-checkout, mantenimiento en segundo plano y monitor de archivos.

Lección 4.7

Submódulos y subtree

A veces un repositorio necesita incluir otro: una librería de componentes compartida, un tema, un SDK. Hay dos formas, con filosofías opuestas.

bash
git submodule add https://github.com/org/ui.git vendor/ui
git clone --recurse-submodules https://github.com/org/app.git
git submodule update --init --recursive      # si clonaste sin la opción anterior
git submodule update --remote vendor/ui      # trae lo último del submódulo
git add vendor/ui && git commit -m "actualiza ui"   # y fija el nuevo puntero
SubmóduloSubtree
Qué guarda el repo padreUn puntero a un commit del otro repoUna copia de los archivos
ClonarNecesita --recurse-submodulesNormal
Bueno paraDependencias con su propio ciclo y versiones exactasIncluir código que rara vez cambia, sin pasos extra
Antes de elegir cualquieraSi el otro repositorio publica paquetes (npm, PyPI, Maven), un administrador de paquetes casi siempre es mejor opción que submódulos o subtree.
Lección 4.8

Estrategias de ramas en equipo

Git no impone cómo organizar las ramas. Cada equipo elige una estrategia, y la elección depende sobre todo de cada cuánto despliegan.

EstrategiaCómo funcionaPara quién
Trunk-basedTodos integran a main a diario con ramas de horas; lo incompleto se esconde con feature flagsEquipos con CI sólido que despliegan varias veces al día
GitHub flowmain siempre desplegable; una rama y un PR por cambioLa mayoría de los equipos web
Git flowRamas develop, release/* y hotfix/*, y main con tags de versiónSoftware con versiones numeradas y soporte largo (apps de escritorio, librerías)
Si dudas

Empieza con GitHub flow: ramas cortas, pull requests y main protegida. Es simple, funciona con equipos de cualquier tamaño y puedes acercarte a trunk-based a medida que mejoran tus pruebas automáticas. Compara todas las estrategias, con animaciones y un asistente para elegir, en Estrategias de ramas.

Lección 4.9

Firmar commits y seguridad

Cualquiera puede poner tu nombre y correo en un commit: user.name es solo texto. Firmar tus commits prueba que salieron de tu llave. GitHub y GitLab los marcan como «Verified». La forma más simple hoy es firmar con tu llave SSH.

bash
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true
git config --global tag.gpgsign true
# y agrega la misma llave en GitHub como "Signing key"
git log --show-signature -1

Hábitos de seguridad

  • Nunca subas secretos. Usa .gitignore, variables de entorno y un escáner en pre-commit. Si se te escapa uno, rótalo primero: borrarlo de la historia no deshace que ya estuvo expuesto.
  • Borrar de la historia se hace con git filter-repo (herramienta aparte, recomendada por el propio proyecto Git en lugar de filter-branch), y requiere coordinar un force push con todo el equipo.
  • Desconfía de repositorios ajenos: un repo puede traer hooks o configuración que ejecute código. Git no copia los hooks al clonar, y safe.directory evita usar repos de otros usuarios del sistema. En Git 3.0, safe.bareRepository pasará a explicit para cerrar otro truco con repos «desnudos».
Lección 4.10

Configuración pro y Git 3.0

Unas pocas opciones hacen a Git más cómodo y más seguro. Ninguna cambia cómo funciona; solo ajustan valores por defecto pensados para no romper hábitos de hace quince años.

~/.gitconfig
[rerere]
	enabled = true          # recuerda cómo resolviste un conflicto y lo repite
[merge]
	conflictStyle = zdiff3  # los marcadores muestran también la versión base
[diff]
	algorithm = histogram   # diffs más legibles
	colorMoved = default    # el código movido se pinta distinto
[push]
	autoSetupRemote = true  # el primer push de una rama crea su upstream
[fetch]
	prune = true            # borra origin/* de ramas que ya no existen
[rebase]
	autoSquash = true
	updateRefs = true       # mueve también las ramas apiladas encima
[branch]
	sort = -committerdate   # git branch: las más recientes primero

rerere («reuse recorded resolution») merece una mención aparte: si resuelves el mismo conflicto varias veces (por ejemplo, al hacer rebase seguido de una rama larga), Git aprende tu resolución y la aplica sola.

Lo que trae Git 3.0

El proyecto Git anunció la transición: la versión de diciembre de 2026 se llama 2.98, y en 2027 llegan la 2.99 (de soporte largo) y Git 3.0. Los cambios afectan a repositorios nuevos; los que ya tienes siguen funcionando.

CambioQué significa para ti
SHA-256 por defectoHashes de 64 caracteres en repos nuevos. Los repos SHA-1 siguen soportados
Reftable por defectoLas refs se guardan en una tabla y no en un archivo por rama: más rápido y sin problemas con mayúsculas en macOS y Windows. Pruébalo hoy con init.defaultRefFormat=reftable
main como rama inicialLo que ya configuraste en la lección 1.2
Comandos retiradosgit whatchanged (usa git log --raw), pack-redundant y los grafts (usa git replace)
Lo que se quedagit checkout no se elimina ni se depreca
Quiz final

Quiz · Nivel Experto

Responde todas correctamente para aprobar