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.
Ruta
Qué es
HEAD
Dó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)
index
El 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.
Hook
Cuándo corre
Uso típico
pre-commit
Antes de crear el commit
Formateo, lint, tests rápidos, buscar secretos
commit-msg
Con el mensaje escrito
Validar Conventional Commits o un ID de ticket
pre-push
Antes de subir
Tests más lentos
post-checkout, post-merge
Después de cambiar de rama o fusionar
Reinstalar 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écnica
Qué recorta
Cuándo
--filter=blob:none (partial clone)
Descarga commits y carpetas, pero el contenido de cada archivo recién cuando lo necesitas
Desarrollo diario en repos grandes
sparse-checkout
Deja en disco solo las carpetas que eliges; la historia sigue completa
Monorepos donde trabajas en una parte
--depth 1 (shallow clone)
Solo los últimos commits
CI 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ódulo
Subtree
Qué guarda el repo padre
Un puntero a un commit del otro repo
Una copia de los archivos
Clonar
Necesita --recurse-submodules
Normal
Bueno para
Dependencias con su propio ciclo y versiones exactas
Incluir 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.
Estrategia
Cómo funciona
Para quién
Trunk-based
Todos integran a main a diario con ramas de horas; lo incompleto se esconde con feature flags
Equipos con CI sólido que despliegan varias veces al día
GitHub flow
main siempre desplegable; una rama y un PR por cambio
La mayoría de los equipos web
Git flow
Ramas develop, release/* y hotfix/*, y main con tags de versión
Software 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.
Cambio
Qué significa para ti
SHA-256 por defecto
Hashes de 64 caracteres en repos nuevos. Los repos SHA-1 siguen soportados
Reftable por defecto
Las 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 inicial
Lo que ya configuraste en la lección 1.2
Comandos retirados
git whatchanged (usa git log --raw), pack-redundant y los grafts (usa git replace)
Lo que se queda
git checkout no se elimina ni se depreca
Quiz final
Quiz · Nivel Experto
Responde todas correctamente para aprobar
¿Y ahora?
Practica en el laboratorio, y guarda la guía de rescate para el día que la necesites.