Git desde cero: una guía completa para principiantes con GitHub CLI y herramientas de IA

Git es el sistema de control de versiones que impulsa casi todos los proyectos de software del planeta. Ya sea que escribas código por tu cuenta o colabores con un equipo de 500 ingenieros, Git registra cada cambio que haces, te permite viajar en el tiempo y evita que las líneas de trabajo paralelas entren en conflicto.

Esta guía empieza desde cero absoluto. Al terminar, entenderás todos los comandos habituales de Git, sabrás cómo instalar y usar GitHub CLI, y aprenderás cómo herramientas de IA como Claude Code y Cursor pueden ejecutar Git por ti, con explicaciones en cinco niveles de profundidad.

¿Qué es Git y por qué debería importarte?

Antes de escribir un solo comando, entiende qué problema resuelve Git.

Cuando escribes código sin Git:

Duplicas carpetas manualmente: project-v1/, project-final/, project-FINAL-final/
Sobrescribes algo y no puedes recuperarlo
Dos personas editan el mismo archivo y el trabajo de una de ellas desaparece
No recuerdas qué cambió entre ayer y hoy

Git resuelve todo esto. Es un sistema de control de versiones distribuido: cada desarrollador tiene el historial completo del proyecto en su máquina. No hay un único punto de falla.

Your machine          Teammate's machine        GitHub (remote)
─────────────         ──────────────────        ───────────────
Full history    ←──→  Full history        ←──→  Full history

Cada «punto de guardado» en Git se llama commit. Los commits forman una cadena (un grafo) llamada historial del repositorio.

Parte 1: Instalación de Git

macOS

# Option 1: Xcode Command Line Tools (simplest)
xcode-select --install

# Option 2: Homebrew (recommended for developers)
brew install git

Linux (Debian/Ubuntu)

sudo apt update && sudo apt install git

Linux (Fedora/RHEL)

sudo dnf install git

Windows

Descarga el instalador desde git-scm.com. Durante la instalación, selecciona «Git Bash» y «Use Git from the Windows Command Prompt».

Verificar la instalación

git --version
# git version 2.44.0

Parte 2: Configuración inicial

Antes de tu primer commit, dile a Git quién eres. Esta información se adjunta a cada commit que haces.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# Set your default branch name to 'main' (modern standard)
git config --global init.defaultBranch main

# Set VS Code as the default editor (optional)
git config --global core.editor "code --wait"

Comprueba que todo esté configurado correctamente:

git config --list

Parte 3: Comandos esenciales de Git — El flujo de trabajo diario

Estos son los comandos que usarás todos los días. Apréndelos primero.

Iniciar un repositorio

# Create a new Git repo in the current folder
git init

# Clone an existing repo from GitHub
git clone https://github.com/username/repo-name.git

# Clone into a specific folder name
git clone https://github.com/username/repo-name.git my-project

Consultar el estado

# See what has changed since your last commit
git status

# See a compact version
git status -s

Explicación de la salida:

On branch main
Changes not staged for commit:
  modified:   src/index.js     ← file changed, not yet staged

Untracked files:
  notes.txt                    ← new file, Git doesn't know about it yet

El área de staging (índice)

Git tiene un proceso de guardado en dos pasos. Primero agregas los cambios al staging (eliges qué incluir) y luego haces un commit (creas la instantánea).

Working directory  →  Staging area  →  Repository history
  (edit files)        (git add)         (git commit)

# Stage a specific file
git add filename.txt

# Stage all changes in the current directory
git add .

# Stage parts of a file interactively (powerful)
git add -p filename.txt

# Unstage a file (keep changes, just remove from staging)
git restore --staged filename.txt

Crear commits

# Commit staged changes with a message
git commit -m "feat: add login form validation"

# Stage all tracked files AND commit in one step
git commit -am "fix: correct typo in header"

# Open your editor to write a detailed commit message
git commit

Ver el historial

# Full commit history
git log

# Compact one-line format
git log --oneline

# Visual branch graph
git log --oneline --graph --all

# Show changes introduced by each commit
git log -p

# Limit to last 5 commits
git log -5 --oneline

Ver las diferencias

# Changes in working directory (not yet staged)
git diff

# Changes that ARE staged (ready to commit)
git diff --staged

# Diff between two commits
git diff abc1234 def5678

# Diff between two branches
git diff main feature/login

Deshacer cambios

# Discard changes to a file (restore to last commit)
git restore filename.txt

# Unstage a file
git restore --staged filename.txt

# Undo the last commit but keep the changes staged
git reset --soft HEAD~1

# Undo the last commit and unstage everything (keep file changes)
git reset HEAD~1

# Create a new commit that reverses a previous one (safe for shared repos)
git revert abc1234

Advertencia: git reset --hard descarta permanentemente todos los cambios que no se hayan incluido en un commit. Úsalo con precaución.

Parte 4: Ramas y merges

Las ramas te permiten trabajar en funcionalidades o correcciones de forma aislada, sin tocar el código principal.

main:    A ── B ── C ────────────── G
                    \              /
feature:             D ── E ── F ──

Conceptos básicos de las ramas

# List all branches
git branch

# List all branches including remote ones
git branch -a

# Create a new branch
git branch feature/user-auth

# Switch to a branch
git switch feature/user-auth

# Create AND switch in one command (modern syntax)
git switch -c feature/user-auth

# Old syntax (still works everywhere)
git checkout -b feature/user-auth

# Delete a branch (after merging)
git branch -d feature/user-auth

# Force delete (even if not merged)
git branch -D feature/user-auth

# Rename current branch
git branch -m new-branch-name

Hacer un merge

# Switch to the branch you want to merge INTO
git switch main

# Merge the feature branch into main
git merge feature/user-auth

# Merge with a commit message (no fast-forward)
git merge --no-ff feature/user-auth -m "Merge feature/user-auth into main"

Resolver conflictos de merge

Cuando dos ramas cambian la misma línea, Git marca el conflicto:

<<<<<<< HEAD
const greeting = "Hello";
=======
const greeting = "Hi there";
>>>>>>> feature/user-auth

Edita el archivo manualmente hasta obtener el resultado deseado, elimina los marcadores y luego:

git add filename.js
git commit -m "resolve merge conflict in greeting"

Rebase (alternativa avanzada a merge)

# Replay your branch commits on top of main (linear history)
git switch feature/user-auth
git rebase main

# Interactive rebase — squash, reorder, or edit last 3 commits
git rebase -i HEAD~3

Parte 5: Trabajar con repositorios remotos

Un remoto es una versión de tu repositorio alojada en un servidor (GitHub, GitLab, Bitbucket, etc.).

# Show configured remotes
git remote -v

# Add a remote (typically done automatically by git clone)
git remote add origin https://github.com/username/repo.git

# Push your branch to the remote (first time)
git push -u origin main

# Push subsequent times
git push

# Pull (fetch + merge) latest changes from remote
git pull

# Fetch without merging (inspect before integrating)
git fetch origin

# Push a new branch to remote
git push -u origin feature/user-auth

# Delete a remote branch
git push origin --delete feature/user-auth

El flujo de push y pull para un equipo

1. git pull            ← get latest changes from teammates
2. (write code)
3. git add .
4. git commit -m "..."
5. git push            ← share your work

Parte 6: Stash

Stash guarda temporalmente el trabajo en curso para que puedas cambiar de contexto.

# Save current changes to the stash
git stash

# Save with a descriptive label
git stash push -m "half-finished login form"

# List all stashes
git stash list

# Apply the most recent stash (keep it in stash list)
git stash apply

# Apply AND remove from stash list
git stash pop

# Apply a specific stash
git stash apply stash@{2}

# Delete a stash
git stash drop stash@{0}

# Clear all stashes
git stash clear

Parte 7: Etiquetas

Las etiquetas marcan puntos específicos del historial, generalmente versiones de lanzamiento.

# Create a lightweight tag
git tag v1.0.0

# Create an annotated tag (recommended — includes message)
git tag -a v1.0.0 -m "First stable release"

# List all tags
git tag

# Push tags to remote (they don't push automatically)
git push origin --tags

# Push a single tag
git push origin v1.0.0

# Delete a local tag
git tag -d v1.0.0

# Delete a remote tag
git push origin --delete v1.0.0

Parte 8: Comandos útiles para el día a día

# See who last changed each line in a file
git blame filename.js

# Search commit history for a string
git log -S "functionName" --oneline

# Find which commit introduced a bug (binary search)
git bisect start
git bisect bad                  # current commit is broken
git bisect good v1.0.0          # this tag was working
# Git checks out midpoints — you test and mark good/bad
git bisect good                 # or: git bisect bad
git bisect reset                # when done

# Show details of a specific commit
git show abc1234

# Clean untracked files (dry run first)
git clean -n
git clean -fd

# See a file as it was at a specific commit
git show abc1234:src/index.js

Parte 9: Instalar y usar GitHub CLI (gh)

GitHub CLI (gh) te permite gestionar pull requests, issues y repositorios desde tu terminal, sin necesidad de un navegador.

Instalación

macOS:

brew install gh

Linux (Debian/Ubuntu):

curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
sudo apt update && sudo apt install gh

Linux (Fedora/RHEL):

sudo dnf install gh

Windows:

winget install --id GitHub.cli
# or
choco install gh

Verificar:

gh --version

Autenticación

gh auth login
# Follow the prompts:
# → GitHub.com
# → HTTPS
# → Login with a web browser
# → Paste the one-time code shown in your terminal

Comandos esenciales de gh

# Create a new repository
gh repo create my-project --public --clone

# Clone a repo (shorthand)
gh repo clone username/repo-name

# View repo in browser
gh repo view --web

# Create a pull request
gh pr create --title "Add login form" --body "Implements #42"

# Create PR with interactive prompt
gh pr create

# List open pull requests
gh pr list

# Review and checkout a PR
gh pr checkout 42

# Merge a PR
gh pr merge 42 --squash

# Create an issue
gh issue create --title "Bug: login crashes on mobile" --body "Steps to reproduce..."

# List issues
gh issue list

# Close an issue
gh issue close 42

# View CI/CD status for current branch
gh run list
gh run view

# Open a PR in the browser
gh pr view --web

Ejemplo de flujo de trabajo con gh

# 1. Start work on a feature
git switch -c feature/dark-mode

# 2. Write code and commit
git add .
git commit -m "feat: add dark mode toggle"

# 3. Push to remote
git push -u origin feature/dark-mode

# 4. Create PR without leaving the terminal
gh pr create --title "feat: add dark mode toggle" --body "Closes #88"

# 5. Check if CI passed
gh run list

# 6. Merge when approved
gh pr merge --squash

Parte 10: Usar Claude Code y Cursor para ejecutar Git por ti

No tienes que memorizar todos los comandos. Las herramientas de programación con IA pueden ejecutar operaciones de Git por ti: solo describe lo que quieres en inglés sencillo.

Claude Code

Claude Code es el agente de IA de Anthropic que funciona en la terminal. Puede leer tus archivos, entender el contexto de tu proyecto y ejecutar comandos de Git por ti.

Cómo usarlo:

# Install Claude Code
npm install -g @anthropic-ai/claude-code

# Start a session in your project
cd my-project
claude

Luego, solo habla con él:

> Stage all my changes and commit them with a good conventional commit message

> Create a new branch called feature/payment-integration and push it to GitHub

> I need to undo my last commit but keep the changes

> Show me what changed in the last 5 commits

> Create a pull request for my current branch targeting main

Claude Code lee tu diff, entiende qué cambió, escribe un mensaje de commit descriptivo y ejecuta los comandos. También explica qué está haciendo y por qué, para que aprendas mientras avanzas.

Ejemplo real de interacción:

You: I finished the login page. Commit everything and push.

Claude Code: I'll stage your changes and create a commit.
Running: git add src/pages/login.tsx src/components/LoginForm.tsx
Running: git commit -m "feat(auth): add login page with form validation"
Running: git push -u origin feature/login-page
Done. Your branch is on GitHub.

Cursor

Cursor es un fork de VS Code con un agente de IA integrado que entiende tu código.

Cómo usar Git en Cursor:

Presiona Cmd+L (Mac) o Ctrl+L (Windows/Linux) para abrir el chat de IA
Escribe lo que necesitas:

Stage all my changes and write a commit message for me

Create a branch for the new payment feature

Show me the git log as a visual graph

Help me resolve this merge conflict in src/api/users.ts

El agente de Cursor ejecuta los comandos en su terminal integrada. También muestra la salida y explica qué ocurrió.

El panel de control de código fuente de Cursor:

Para flujos de trabajo visuales con Git, Cursor hereda el panel de control de código fuente integrado en VS Code (Ctrl+Shift+G). Puedes agregar cambios al staging, quitarlos del staging, hacer commits y ver diffs gráficamente, sin necesidad de comandos.

Cuándo usar herramientas de IA y cuándo aprender los comandos

Situación	Recomendación
Aprender los fundamentos de Git	Escribe los comandos manualmente: la memoria muscular importa
Tareas repetitivas (commit, push, PR)	Deja que las herramientas de IA se encarguen
Operaciones complejas (rebase, bisect)	Pídele a la IA que las explique Y las ejecute: aprende de ella
Situaciones de emergencia (commits perdidos)	Usa la asistencia de IA: hay menos margen de error
Enseñar a otra persona	Usa comandos manuales para poder explicar cada paso

Flujo de datos y modelos mentales

Los cuatro estados de Git

┌──────────────────────────────────────────────────────┐
│  Untracked  │  Modified  │  Staged  │  Committed     │
│  (new file) │  (changed) │  (index) │  (history)     │
│             │            │          │                 │
│  git add ──────────────►│          │                 │
│             │  git add ──────────►│                  │
│             │            │ git commit ──────────────► │
│             │◄── git restore ─────│                  │
│             │            │◄── git restore --staged   │
└──────────────────────────────────────────────────────┘

El flujo de trabajo con remotos

Local                           Remote (GitHub)
─────                           ───────────────

git init / git clone ←────────── origin/main

git add + git commit
      │
      ▼
Local commits ──── git push ───► origin/main
                                      │
Other people's commits ◄─ git pull ───┘

Estrategias de merge de ramas

Fast-forward merge (no divergence):
main:    A ── B
feature:      B ── C ── D
result:  A ── B ── C ── D   (linear, clean)

Three-way merge (diverged):
main:    A ── B ── C ────────── M
                    \          /
feature:             D ── E ──   (merge commit M created)

Rebase (replay commits):
main:    A ── B ── C
feature:      B ── D'── E'    (D and E replayed on top of C)

Cinco niveles de comprensión

Nivel 1 — Básico: ¿Qué hace Git?

Git es una máquina del tiempo para tu código. Cada git commit toma una instantánea. Siempre puedes volver atrás. Las ramas son líneas de tiempo paralelas. push envía tu trabajo a GitHub. pull trae el trabajo de otras personas.

Los tres comandos que necesitas para sobrevivir:

git add .
git commit -m "describe what you did"
git push

Nivel 2 — Intermedio: El modelo de staging

El área de staging de Git (índice) existe por una razón. Te permite construir commits con precisión, agregando al staging solo los cambios relevantes para una unidad lógica, aunque hayas editado muchos archivos.

Un buen commit responde: «Si se aplica, este commit…». Cada commit debe representar un cambio lógico. Esto hace que git log, git bisect y la revisión de código sean mucho más útiles.

Los comandos clave en este nivel: git diff, git diff --staged, git log --oneline --graph, git stash, git branch.

Nivel 3 — Avanzado: El grafo de commits

Git almacena los datos como un grafo acíclico dirigido (DAG) de objetos commit. Cada commit contiene:

Un puntero al objeto tree (una instantánea del sistema de archivos)
Un puntero al commit o los commits padre
Autor, marca de tiempo y mensaje
Un hash SHA-1 que lo identifica de forma única

commit abc1234
├── tree: root directory snapshot
├── parent: def5678
├── author: Luis <luis@example.com>
└── message: "feat: add login form"

HEAD es simplemente un puntero al commit actual. Las ramas son punteros a commits. git reset mueve estos punteros. git rebase crea nuevos commits con los mismos cambios, pero con padres diferentes.

Nivel 4 — Experto: Funcionamiento interno y rendimiento

El almacén de objetos de Git usa almacenamiento direccionado por contenido. Dos archivos con contenido idéntico comparten un mismo objeto blob. Esto permite que Git use el espacio de forma eficiente en repositorios grandes.

Los archivos pack (.git/objects/pack/) agrupan objetos mediante compresión delta. git gc activa la recolección de basura y el reempaquetado.

Para mejorar el rendimiento a gran escala:

git fetch --depth=1 para clones superficiales en CI/CD
git sparse-checkout para monorepos (descarga solo lo que necesitas)
git worktree para tener varias ramas activas simultáneamente
.gitattributes para la configuración de LFS (almacenamiento de archivos grandes)
git maintenance para la optimización programada en segundo plano

Rebase reescribe el historial: los hashes SHA cambian. Nunca hagas rebase de commits que se hayan enviado a una rama compartida. Usa git revert en su lugar (agrega un commit y es seguro).

Nivel 5 — Legendario: Arquitectura y flujos de trabajo en equipo

A gran escala, el diseño del flujo de trabajo de Git se convierte en una decisión arquitectónica con consecuencias reales para la organización.

Desarrollo basado en trunk (usado por Google, Meta): todos hacen commits directamente en main con feature flags. Minimiza los conflictos de merge. Requiere un CI/CD sólido y disciplina.

GitFlow: ramas estructuradas para main, develop, feature/*, release/*, hotfix/*. Mayor sobrecarga; es mejor para software versionado con lanzamientos programados.

GitHub Flow: simplificado, con main y ramas de funcionalidades de corta duración. Se requiere un pull request para cada merge. Es una buena opción predeterminada para la mayoría de los equipos.

La elección afecta:

Con qué frecuencia ocurren conflictos de integración
Qué tan rápido llegan las funcionalidades a producción
Qué tan fáciles son los rollbacks
Cómo se incorporan los nuevos integrantes al equipo

La naturaleza distribuida de Git también significa que cada clon es una copia de respaldo completa. Es posible recuperarse de fallas catastróficas del servidor desde la máquina de cualquier desarrollador. Esto no es una coincidencia: Linus Torvalds lo diseñó así después de que el servidor CVS central del proyecto del kernel de Linux sufriera una pérdida de datos.

Preguntas para profundizar

¿Cuál es la diferencia entre git merge y git rebase, y cuándo debería usar cada uno?
¿Cómo me ayuda git bisect a encontrar exactamente qué commit introdujo un bug?
¿Qué son los hooks de Git y cómo puedo automatizar tareas al hacer un commit o push?
¿Cómo funciona el proceso de revisión de pull requests de GitHub y qué hace que un PR sea bueno?
¿Qué es un monorepo y cómo maneja Git los repositorios muy grandes?
¿Cómo configuro claves SSH en lugar de HTTPS para la autenticación en GitHub?
¿Qué es git reflog y cómo puede salvarme cuando creo que perdí commits?
¿Cómo maneja Git los archivos binarios y qué es Git LFS?
¿Qué es el desarrollo basado en trunk y por qué lo prefieren las grandes empresas?
¿Cómo puedo configurar commitlint y Husky para aplicar automáticamente convenciones en los mensajes de commit?

Fuentes

Libro Pro Git — Scott Chacon y Ben Straub — La referencia gratuita definitiva, abarca desde los fundamentos hasta el funcionamiento interno
Documentación de GitHub CLI — Referencia oficial de comandos de gh
Guía de instalación de GitHub CLI
Documentación oficial de Git — Referencias de comandos y tutoriales
Conventional Commits v1.0.0 — Especificación de mensajes de commit
Tutoriales de Git de Atlassian — Explicaciones visuales de ramas y merges
Git Branching — Aprende Git Branching (interactivo) — Ejercicios visuales de Git en el navegador
GitHub Docs — Acerca de los pull requests
Documentación de Claude Code — Anthropic
Documentación de Cursor
Cómo escribir un mensaje de commit de Git — Chris Beams
Desarrollo basado en trunk — trunkbaseddevelopment.com
Funcionamiento interno de Git — Plumbing y Porcelain