Comandos Git y GitHub: Guía Completa 2026 para VS Code, Claude Code y Cursor

Introducción

Tras configurar entornos de desarrollo para decenas de proyectos en KodFlux este 2026, la pregunta recurrente sigue siendo la misma: “¿Cuáles son los comandos Git que realmente uso día a día?”. No necesitas memorizar los 100+ comandos que existen; solo los 15-20 que resuelven el 95% de tu flujo de trabajo.

Esta guía condensa los comandos esenciales de Git y GitHub explicados con ejemplos reales, y te muestra exactamente dónde ejecutarlos: terminal nativa, VS Code, Cursor, Claude Code, OpenCode o el nuevo Antigravity. Al final tendrás un cheatsheet listo para imprimir o guardar en tu dotfiles.

Comandos Git Esenciales (Tu Daily Driver)

Estos son los comandos que ejecutarás cientos de veces al mes. Ordénalos mentalmente en el flujo estándar: init → add → commit → push → pull → branch → merge.

1. Inicializar y Clonar Repositorios

# Iniciar repo local en carpeta actual
git init

# Clonar repo remoto (HTTPS - recomendado para empezar)
git clone https://github.com/usuario/repo.git

# Clonar repo remoto (SSH - si ya tienes llaves configuradas)
git clone git@github.com:usuario/repo.git

# Clonar rama específica
git clone -b develop https://github.com/usuario/repo.git

Experiencia KodFlux: Usa siempre SSH en equipos propios (evita ingresar token cada push). En CI/CD o contenedores efímeros, HTTPS con Personal Access Token es más portable.

2. Estado, Stage y Commit (El Ciclo Básico)

# Ver estado de archivos (modificados, staged, untracked)
git status

# Ver cambios exactos en archivos modificados
git diff                    # cambios no staged
git diff --staged           # cambios ya en stage

# Añadir archivos al stage (preparar para commit)
git add archivo.js          # archivo específico
git add .                   # todo el directorio actual (cuidado con basura)
git add -p                  # modo interactivo (revisa hunk por hunk)

# Commit con mensaje descriptivo
git commit -m "feat: añade autenticación JWT en middleware"

# Commit enmendado (corregir último commit sin nuevo commit)
git commit --amend -m "fix: corrige typo en variable de entorno"

# Commit vacío (útil para disparar CI/CD)
git commit --allow-empty -m "chore: trigger deploy"

3. Historial y Navegación

# Log compacto y legible (mi alias favorito)
git log --oneline --graph --decorate -20

# Log con autor, fecha y mensaje completo
git log --pretty=format:"%h %ad | %s%d [%an]" --date=short

# Ver qué cambió en un commit específico
git show <hash>

# Ver quién tocó cada línea de un archivo (blame)
git blame archivo.js

# Buscar commits por mensaje o autor
git log --grep="JIRA-123"
git log --author="Juan"

4. Ramas (Branching) y Merge

# Listar ramas locales y remotas
git branch -a

# Crear y cambiar a nueva rama
git checkout -b feature/nueva-funcionalidad
# O en Git 2.23+ (recomendado)
git switch -c feature/nueva-funcionalidad

# Cambiar de rama
git switch main
git switch feature/nueva-funcionalidad

# Fusionar rama en actual (merge commit)
git merge feature/nueva-funcionalidad

# Fusionar con *fast-forward* only (historial lineal)
git merge --ff-only feature/nueva-funcionalidad

# Rebase interactivo (limpiar historial antes de PR)
git rebase -i HEAD~5

# Eliminar rama local y remota
git branch -d feature/nueva-funcionalidad
git push origin --delete feature/nueva-funcionalidad

5. Sincronizar con Remoto (Push, Pull, Fetch)

# Ver remotos configurados
git remote -v

# Añadir remoto (origin por convención)
git remote add origin https://github.com/usuario/repo.git

# Subir rama por primera vez (establece upstream)
git push -u origin feature/nueva-funcionalidad

# Push normal (rama ya trackea remoto)
git push

# Push forzado (¡cuidado! solo en tu feature branch)
git push --force-with-lease

# Traer cambios remotos y fusionar (pull = fetch + merge)
git pull

# Traer cambios sin fusionar (revisa primero)
git fetch origin
git log HEAD..origin/main --oneline

# Pull con rebase (historial más limpio)
git pull --rebase

6. Deshacer Cambios (Tu Red de Seguridad)

# Descartar cambios en archivo no staged (¡irreversible!)
git checkout -- archivo.js
# O Git 2.23+
git restore archivo.js

# Quitar archivo del stage (mantiene cambios en working dir)
git reset HEAD archivo.js
git restore --staged archivo.js

# Volver al commit anterior (soft: mantiene cambios staged)
git reset --soft HEAD~1

# Volver al commit anterior (mixed: default, cambios unstaged)
git reset HEAD~1

# Volver al commit anterior (hard: ¡PIERDE CAMBIOS LOCALES!)
git reset --hard HEAD~1

# Revertir commit público (crea commit inverso, seguro para shared branches)
git revert <hash>

7. Stashing (Guardar Temporal)

# Guardar cambios actuales en stash
git stash
git stash push -m "WIP: refactor auth module"

# Listar stashes
git stash list

# Aplicar último stash y eliminarlo de la pila
git stash pop

# Aplicar stash específico sin eliminarlo
git stash apply stash@{2}

# Eliminar stash específico
git stash drop stash@{1}

# Limpiar todos los stashes
git stash clear

8. Tags y Releases

# Crear tag anotado (recomendado para releases)
git tag -a v1.2.0 -m "Release 1.2.0: añade paginación API"

# Subir tags al remoto
git push origin --tags

# Ver tags
git tag -l "v1.*"

# Eliminar tag local y remoto
git tag -d v1.2.0
git push origin --delete v1.2.0

---

¿Qué es un Comando Git? (Concepto Clave)

Un comando Git es una instrucción CLI que interactúa con el sistema de control de versiones distribuido Git (creado por Linus Torvalds en 2005). Cada comando manipula el repositorio local (carpeta .git/) o sincroniza con remotos (GitHub, GitLab, Bitbucket).

Git ≠ GitHub. Git es la herramienta local; GitHub es el hosting remoto + capa social (PRs, Issues, Actions). Los comandos push, pull, fetch, clone hablan con GitHub; el resto (commit, branch, merge, rebase, log) son 100% locales.

---

Ejecutar Comandos Git Desde Diferentes Entornos (2026)

Aquí está la diferencia real: los comandos son idénticos, solo cambia dónde abres la terminal.

1. Terminal Nativa (Windows PowerShell / Bash / Zsh)

# Windows: PowerShell 7+ (recomendado) o Git Bash
# Mac/Linux: Terminal.app, iTerm2, Alacritty, Kitty

# Navega a tu proyecto
cd C:\proyectos\mi-app

# Ejecuta cualquier comando git
git status
git push

2. VS Code (El Estándar de la Industria)

Atajos esenciales:

• Ctrl + Ñ (tecla backtick) → Abre Terminal Integrada (PowerShell/Bash)
• Ctrl + Shift + G → Panel Source Control (GUI visual)
• Ctrl + Shift + P → “Git: Clone” / “Git: Push” / “Git: Create Branch”

Flujo visual vs CLI:

Acción	Panel Source Control (GUI)	Terminal Integrada (CLI)
Ver cambios	Click archivo → diff lateral	git diff
Stage	Click + junto al archivo	git add archivo
Commit	Escribe mensaje + Ctrl+Enter	git commit -m "msg"
Push/Pull	Botones ↑↓ en barra superior	git push / git pull
Ramas	Click nombre rama → selector	git switch -c rama

Tip Pro: Activa "git.enableSmartCommit": true en settings.json para commitear directo desde el editor con // @commit: mensaje.

3. Cursor (VS Code + IA Nativa)

Igual que VS Code (es un fork), pero con superpoderes:

• Ctrl + K → Chat IA pide: “Haz commit convencional de estos cambios”
• Ctrl + L → Composer genera comandos complejos: “Crea rama, haz rebase interactivo y push forzado”
• Terminal integrada idéntica (Ctrl + Ñ)

4. Claude Code (Anthropic – Agente en Tu Terminal)

# Instalación (una vez)
npm install -g @anthropic-ai/claude-code

# En tu proyecto
cd mi-proyecto
claude-code

# Dentro de la sesión, usa lenguaje natural:
> "Crea rama feature/login, haz commit de los cambios en auth.ts y abre PR"
> "Haz rebase interactivo de los últimos 3 commits y squashéalos"
> "Configura git hooks con husky para lint-staged"

Claude Code ejecuta los comandos Git por ti y explica cada paso. Ideal para flujos complejos (rebase, cherry-pick, bisect).

5. OpenCode (Agente Open Source – Local First)

# Instalación
brew install opencode  # Mac
# O descarga binario en GitHub Releases

# Uso
cd mi-proyecto
opencode

# Prompts equivalentes:
> "git add . && git commit -m 'feat: nuevo dashboard' && git push"
> "Muéstrame diff de lo que voy a commitear"
> "Deshaz el último commit manteniendo cambios"

OpenCode corre 100% local (usa tu LLM local via Ollama o API keys). Privacidad total.

6. Codex (OpenAI – En La Nube / VS Code Extension)

• Web: chat.openai.com/codex → pide comandos, copia y pega en tu terminal
• VS Code Ext: “Codex” → panel lateral → genera comandos Git contextualizados
• Diferencia: No ejecuta directamente en tu repo (salvo en entornos sandbox). Tú copias/pegas.

7. Antigravity (Nuevo – GitHub Native CLI)

# Instalación
gh extension install github/gh-antigravity

# Uso (autentica con gh auth login)
antigravity sync          # Sincroniza forks, PRs, issues
antigravity pr create     # Crea PR interactivo
antigravity stack         # Maneja stacked PRs (dependent PRs)

Antigravity extiende gh (GitHub CLI) para flujos avanzados: stacked diffs, auto-rebase, merge queues. No reemplaza a git, lo complementa.

---

Tabla Comparativa: Entorno vs Flujo Git

---

Cheatsheet Rápido: 20 Comandos Que Usarás Esta Semana

Comando	Qué Hace	Cuándo Usarlo
git status	Estado working tree + stage	Siempre antes de cualquier acción
git add -A	Stage todo (incluye borrados)	Commit completo
git commit -m "msg"	Crea snapshot local	Cada unidad lógica de cambio
git push	Sube commits a remoto	Tras commit, para backup/colaborar
git pull --rebase	Trae y reaplica tus commits	Evita merge commits innecesarios
git switch -c rama	Crea y cambia a rama	Nueva feature/fix
git merge rama	Fusiona rama en actual	Integración final (PR mergeado)
git rebase -i HEAD~n	Reescribe historial local	Limpiar antes de PR
git log --oneline -10	Historial compacto	Ver qué pasó rápido
git diff	Cambios no staged	Revisar antes de add
git stash	Guarda cambios temporal	Cambio de contexto urgente
git restore archivo	Descarta cambios locales	”Me arrepiento de esto”
git reset --soft HEAD~1	Deshace commit, keep staged	Corregir mensaje/archivos
git tag -a v1.0 -m "msg"	Marca release	Versionado semántico
git fetch -p	Trae refs remotos, poda borrados	Antes de revisar ramas remotas
git blame archivo	Autor por línea	Debug: ¿quién rompió esto?
git bisect start	Binary search bug	Encontrar commit que introdujo bug
git cherry-pick hash	Aplica commit específico	Backport fix a rama release
git worktree add ../path rama	Múltiples working trees	Paralelizar features sin stash
gh pr create --fill	Crea PR desde CLI (GitHub CLI)	Flujo GitHub nativo

---

Preguntas Frecuentes (FAQ Optimizado para AEO)

¿Cuáles son los comandos para subir cambios a GitHub?

git add .
git commit -m "feat: descripción clara"
git push origin main
# O si es primera vez la rama:
git push -u origin feature/nueva-rama

¿Cómo hacer un push en Git desde VS Code?

1. Ctrl + Shift + G → Panel Source Control
2. Escribe mensaje de commit
3. Ctrl + Enter → Commitea
4. Click botón ↑ (Push) en barra superior o ... → Push

¿Qué hace el comando git log?

Muestra el historial de commits. Con flags útiles:

• --oneline: una línea por commit
• --graph: dibuja ramas/merges ASCII
• --all: todas las ramas
• -p: muestra diff de cada commit

¿Cómo ver cambios en Git?

• git diff → cambios no staged
• git diff --staged → cambios ya en stage
• git diff HEAD → cambios totales vs último commit
• git diff rama1..rama2 → diff entre ramas

¿Cómo trabajar con Git en equipo (flujo básico)?

1. git pull --rebase al iniciar día
2. git switch -c feature/tarea para nueva tarea
3. Commits atómicos frecuentes (git add -p ayuda)
4. git push -u origin feature/tarea
5. Abre Pull Request en GitHub
6. Code review → git rebase -i si piden cambios
7. Merge PR → git switch main && git pull && git branch -d feature/tarea

---

Conclusión

Dominar Git no es memorizar 100 banderas; es internalizar 15 comandos y saber dónde ejecutarlos según tu flujo. En 2026 tienes opciones:

• Terminal nativa → control total, scripting
• VS Code / Cursor → mejor equilibrio GUI + CLI + IA
• Claude Code / OpenCode → delegar flujos complejos a agentes
• Antigravity / gh → flujos GitHub-native (PRs stacked, merge queues)

Mi recomendación: usa VS Code/Cursor como daily driver (terminal integrada + Source Control), y abre Claude Code cuando te enfrentes a rebase interactivo, bisect o cherry-pick entre ramas. Guarda este artículo como cheatsheet y verás cómo tu velocidad con Git se duplica en dos semanas.

¿Te quedó duda con algún comando o flujo? Déjalo en comentarios y lo ampliamos.

---

Artículo mantenido por el equipo de KodFlux. Última verificación de comandos: Agosto 2026. Para sugerencias técnicas, abre issue en nuestro repo.