Saltar al contenido

Git para trabajar con agentes de IA: commits pequeños antes de cada cambio

Guía/ 12 min de lectura

Haz commit antes de pedir, dale al agente su propia rama, revisa el diff y las pruebas, y aprende qué comando de git te regresa sin perder nada.

  • Git
  • IA
  • Claude Code
En este artículo (8)
  1. Por qué hacer commit antes de un cambio grande
  2. Rama aparte para el agente
  3. Revisar el diff y probar
  4. Volver atrás de forma segura con git restore y git reset
  5. Commits pequeños y mensajes claros
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

Para trabajar con git y un agente de IA sin miedo, haz un commit antes de pedir un cambio grande, deja que el agente trabaje en una rama aparte, revisa el diff y corre las pruebas antes de guardar. Si algo sale mal, git restore y git reset te devuelven al último punto seguro.

Corrimos todos los comandos de este artículo con git 2.54 en un repositorio de prueba: una tienda con un carrito y sus pruebas en Node, donde el «agente» agrega un descuento por volumen (simulamos sus cambios copiando archivos, para poder repetirlo). Las salidas que ves son las reales. Si lo que el agente rompió es un error concreto, primero repórtale el bug con el error, los pasos y dónde buscar.

Por qué hacer commit antes de un cambio grande

Un agente puede tocar diez archivos en un minuto. Si antes de pedirle el cambio tenías trabajo sin commit, tus cambios y los suyos quedan mezclados, y separarlos se vuelve trabajo manual. Un commit antes de pedir es un punto seguro: todo lo que pase después lo puedes comparar con él y volver a él.

Empieza por mirar el estado con git status:

$ git status --short
 M README.md
  • --short da una línea por archivo.
  • M (espacio y M): archivo modificado que todavía no está en el stage.
  • ??: archivo nuevo que git no sigue. Lo vas a ver cuando el agente cree archivos.
  • Sin salida: no hay nada pendiente.

Guarda ese trabajo antes de pedir nada:

$ git add -A
$ git commit -m "Documenta cómo correr las pruebas"
[main 7994890] Documenta cómo correr las pruebas
 1 file changed, 2 insertions(+)
  1. git add -A pasa al stage todo el árbol: archivos nuevos, cambiados y borrados (git add).
  2. git commit -m crea el commit con ese mensaje (git commit).
  3. La salida dice la rama, el hash corto y el resumen. 7994890 es tu punto seguro.

¿Y los checkpoints del editor? Claude Code guarda checkpoints y tiene /rewind para volver a un punto anterior de la conversación, pero sus buenas prácticas avisan que solo cubren los archivos que Claude editó con sus propias herramientas, no los que cambió un comando de Bash, y que funcionan junto con git, no en su lugar.

Rama aparte para el agente

Con el punto seguro hecho, crea una rama para la tarea del agente:

$ git switch -c agente/descuento-volumen
Switched to a new branch 'agente/descuento-volumen'

git switch -c crea la rama desde donde estás y se cambia a ella en un solo paso; si el cambio de rama falla, la rama no se crea. El prefijo agente/ es una convención nuestra: así, en la lista de ramas, se distingue qué es trabajo del agente.

La rama es lo que te da libertad. main se queda como estaba, y en la rama del agente puedes descartar, rehacer y usar git reset --hard sin afectar a main ni a nadie del equipo. Cuando el resultado está bien y tiene su commit, lo integras:

$ git switch main
Switched to branch 'main'
$ git merge --ff-only agente/descuento-volumen
Updating 7994890..90b20a1
Fast-forward
 src/carrito.js         |  4 +++-
 test/descuento.test.js | 15 +++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 test/descuento.test.js
$ git branch -d agente/descuento-volumen
Deleted branch agente/descuento-volumen (was 90b20a1).
  1. git switch main vuelve a la rama principal.
  2. git merge --ff-only integra solo si puede avanzar main hasta el último commit de la rama sin crear un commit de merge. Si main avanzó por otro lado, se niega y termina con error, y tú decides qué hacer.
  3. git branch -d borra la rama, pero solo si ya está integrada.

Si el intento no sirve, tira la rama entera. -d se niega porque la rama tiene commits que main no tiene, y -D (atajo de --delete --force) la borra de todas formas:

$ git branch -d agente/intento-2
error: the branch 'agente/intento-2' is not fully merged
hint: If you are sure you want to delete it, run 'git branch -D agente/intento-2'
$ git branch -D agente/intento-2
Deleted branch agente/intento-2 (was 44f0b26).
puntos seguros en la historia de gitmaindb99c07punto seguro7994890main avanza90b20a1agente/descuento-volumencommit90b20a1intento 2merge --ff-onlygit reset --hardcommit antes de pedirtrabajo sin commit: se puede tirarsi tiene commit, puedes volverlo que no tiene commit, git reset --hard lo borra para siempre

Desliza la figura para verla completa

Revisar el diff y probar

Cuando el agente termina, no hagas commit todavía. Primero mira qué tocó:

$ git status --short
 M src/carrito.js
?? test/descuento.test.js
$ git diff --stat
 src/carrito.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

Fíjate en la diferencia: git status muestra el test nuevo con ??, pero git diff --stat no lo cuenta. git diff sin argumentos compara tus archivos con el stage, y un archivo que git todavía no sigue no está ahí. Si solo miras el diff, no ves lo que el agente creó.

Después lee el diff completo:

$ git diff
diff --git a/src/carrito.js b/src/carrito.js
index 08546fa..ab08cc0 100644
--- a/src/carrito.js
+++ b/src/carrito.js
@@ -1,6 +1,7 @@
 // Carrito de la tienda de prueba. Precios en centavos.

 export function agregarLinea(carrito, linea) {
+  console.log("agregando", linea.sku);
   carrito.lineas.push(linea);
 }

@@ -11,8 +12,10 @@ export function quitarLinea(carrito, sku) {

 export function totalCarrito(carrito) {
   let total = 0;
+  let piezas = 0;
   for (const linea of carrito.lineas) {
     total += linea.precio * linea.cantidad;
+    piezas += linea.cantidad;
   }
-  return total;
+  return piezas >= 3 ? Math.round(total * 0.9) : total;
 }
  1. Las líneas con + son nuevas, las de - se quitaron y las demás son contexto.
  2. El primer bloque (@@ -1,6 +1,7 @@) agrega un console.log en agregarLinea. Nadie lo pidió: es depuración que se quedó.
  3. El segundo bloque es el descuento: cuenta piezas y aplica 10% desde 3. Esto sí lo pediste.

Para ver también los archivos nuevos, pásalos al stage y compara el stage con el último commit (--staged es sinónimo de --cached):

$ git add -A
$ git diff --staged --stat
 src/carrito.js         |  5 ++++-
 test/descuento.test.js | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

Y corre las pruebas. En la demo, npm test pasó 4 de 4: las dos que ya existían y las dos nuevas del descuento. Si una prueba que ya existía cambió para poder pasar, pregunta por qué antes de aceptarlo.

pedir, revisar y luego commit o volverpedir el cambioen la rama del agenterevisargit status · git diffnpm test¿está bien?solo lo pedidoy pruebas en verdesínodescartar (rama del agente)git restore <archivo>git reset --hard · git clean -fguardargit add -p · git commit -mun commit por cambiovuelve a pedirantes de pedir: git status limpio y un commit de punto segurorevisa antes del commit, no despuésgit diff no muestra archivos nuevos: búscalos con ?? en git status

Desliza la figura para verla completa

Volver atrás de forma segura con git restore y git reset

git tiene tres comandos con nombres parecidos, y su documentación los separa así: git revert crea un commit nuevo que deshace otros; git restore restaura archivos sin mover tu rama; git reset mueve la punta de la rama y cambia la historia.

SituaciónComandoQué pierdes
Un archivo quedó malgit restore <archivo>Los cambios sin commit de ese archivo
Pasaste algo al stage por errorgit restore --staged <archivo>Nada: el cambio sigue en el archivo
Todo el intento salió malgit reset --hardTodos los cambios sin commit de los archivos que git sigue
Quedaron archivos nuevosgit clean -n y luego git clean -fLos archivos que git no sigue
El commit del agente sobragit reset --hard <commit>Los commits posteriores, recuperables con git reflog
Ya lo compartistegit revert <commit>Nada: crea un commit nuevo

En la demo, el segundo intento del agente dejó un desastre: dos archivos cambiados y un archivo de depuración nuevo.

$ git status --short
 M src/carrito.js
 M test/carrito.test.js
?? src/tmp-depuracion.js
$ git restore test/carrito.test.js
$ git status --short
 M src/carrito.js
?? src/tmp-depuracion.js
$ git reset --hard
HEAD is now at 90b20a1 Agrega 10% de descuento desde 3 piezas
$ git status --short
?? src/tmp-depuracion.js
$ git clean -n
Would remove src/tmp-depuracion.js
$ git clean -f
Removing src/tmp-depuracion.js
  1. git restore <archivo> devuelve ese archivo a como está en el stage; si no lo habías agregado, es como en el último commit. Los demás no se tocan.
  2. git reset --hard sin commit usa HEAD: deja archivos y stage como en el último commit.
  3. El archivo nuevo sobrevivió al reset: git reset --hard no se ocupa de los archivos que git no sigue.
  4. git clean -n muestra qué borraría, sin borrar. -f borra. Sin -f, git se niega por defecto. Si el agente creó carpetas, agrega -d: git clean -nd y git clean -fd.

Cuidado con git reset --hard. Borra todos los cambios sin commit de los archivos que git sigue, y lo que nunca tuvo commit no se recupera ni con git reflog. Úsalo solo en la rama de trabajo del agente, después de mirar git status, y nunca con trabajo tuyo pendiente.

Para deshacer el commit del agente, mueve la rama al punto seguro. Si te arrepientes, el commit no se perdió: git reflog registra a dónde apuntó HEAD en cada movimiento.

$ git reset --hard 7994890
HEAD is now at 7994890 Documenta cómo correr las pruebas
$ git reflog -3
7994890 HEAD@{0}: reset: moving to 7994890
90b20a1 HEAD@{1}: reset: moving to HEAD
90b20a1 HEAD@{2}: commit: Agrega 10% de descuento desde 3 piezas
$ git reset --hard 'HEAD@{1}'
HEAD is now at 90b20a1 Agrega 10% de descuento desde 3 piezas
  1. git reset --hard 7994890 mueve la rama al punto seguro y deja los archivos como estaban ahí.
  2. git reflog -3 muestra los últimos tres movimientos. HEAD@{0} es donde estás; HEAD@{1}, el movimiento anterior.
  3. 'HEAD@{1}' va entre comillas: en PowerShell, sin ellas, el comando falla. En bash y zsh funciona igual con o sin comillas.
  4. El reflog no es eterno: por defecto, las entradas duran 90 días y las de commits que ya no están en ninguna rama, 30.

Si el cambio ya está en main o ya lo subiste, no muevas la historia: la documentación de git reset pide no hacerlo con commits que ya le diste a alguien más. Usa git revert, que crea un commit nuevo con el cambio contrario (necesita el árbol limpio):

$ git revert --no-edit HEAD
[main 0768f21] Revert "Agrega 10% de descuento desde 3 piezas"
 Date: Fri Oct 30 10:00:00 2026 -0600
 2 files changed, 1 insertion(+), 18 deletions(-)
 delete mode 100644 test/descuento.test.js

--no-edit usa el mensaje automático sin abrir el editor.

Commits pequeños y mensajes claros

Un commit por cambio lógico. Si el agente hizo dos cosas, haz dos commits, o deja fuera lo que no pediste. En la demo, el diff traía el descuento (pedido) y un console.log (no pedido). Primero saca el archivo del stage y después elige bloque por bloque con git add -p:

$ git restore --staged src/carrito.js
$ git add -p src/carrito.js
(1/2) Stage this hunk [y,n,q,a,d,k,K,j,J,g,/,e,p,P,?]?
(2/2) Stage this hunk [y,n,q,a,d,K,J,g,/,s,e,p,P,?]?
$ git diff --staged --stat
 src/carrito.js         |  4 +++-
 test/descuento.test.js | 15 +++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)
$ git commit -m "Agrega 10% de descuento desde 3 piezas"
[agente/descuento-volumen 90b20a1] Agrega 10% de descuento desde 3 piezas
 2 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 test/descuento.test.js
$ git restore src/carrito.js
$ git status --short
  1. git restore --staged saca el archivo del stage; el cambio sigue en el archivo.
  2. git add -p enseña cada bloque del diff y pregunta. Respondimos n al primero (el console.log) y y al segundo (el descuento). Las otras respuestas útiles: q para salir y s para dividir un bloque, cuando se puede.
  3. El stage ya marca 4 +++- en lugar de 5 ++++-: el console.log se quedó fuera.
  4. git restore src/carrito.js descarta lo que no entró al commit. Como restaura desde el stage, que ya es igual al commit, el descuento se queda y el console.log se va. git status --short sin salida: limpio.

Para el mensaje, la documentación de git commit recomienda una primera línea corta, de no más de 50 caracteres, que resuma el cambio, luego una línea en blanco y después el detalle si hace falta. «Agrega 10% de descuento desde 3 piezas» tiene 38. Con mensajes así, el historial se vuelve tu lista de puntos seguros:

$ git log --oneline
90b20a1 Agrega 10% de descuento desde 3 piezas
7994890 Documenta cómo correr las pruebas
db99c07 Carrito con pruebas
chuleta de git: qué comando para cada casosituacióncomandover qué cambiógit status --short · git diffpunto seguro antes de pedirgit add -A · git commit -m "..."rama para el agentegit switch -c agente/<tarea>descartar un archivogit restore <archivo>sacar un archivo del stagegit restore --staged <archivo>descartar todo sin commitgit reset --hardborrar archivos nuevosgit clean -n · git clean -fvolver a un punto segurogit reset --hard <commit>deshacer en rama compartidagit revert <commit>recuperar tras un resetgit reflogen cian: borra lo que no tiene commitúsalo solo en la rama del agente y después de mirar git status

Desliza la figura para verla completa

Errores comunes

  • Pedir el cambio con trabajo tuyo sin commit. Si después usas git reset --hard, se lleva lo tuyo junto con lo del agente.
  • Dejar que el agente trabaje en main. Una rama por tarea cuesta un comando y te deja tirar todo sin consecuencias.
  • Revisar solo git diff. No muestra archivos nuevos; búscalos con ?? en git status.
  • Usar git reset --hard sin mirar antes. Un git status de un segundo evita borrar lo que no querías.
  • Usar reset en una rama compartida. Si ya hiciste push, usa git revert.
  • Un commit gigante de «cambios del agente». Si algo falla después, no sabrás qué parte revertir.
  • Confiar solo en los checkpoints del editor. No cubren lo que cambió un comando de terminal.

Preguntas frecuentes

¿El agente puede hacer los commits por mí?

Sí. Claude Code puede correr git si se lo permites, pero revisa el diff antes de que lo guarde. Para git push, conviene que siempre te pregunte: las buenas prácticas de Claude Code muestran justo esa regla, "ask": ["Bash(git push *)"], en .claude/settings.json.

¿Se puede deshacer un git reset --hard?

Los commits, sí: búscalos en git reflog y vuelve con git reset --hard 'HEAD@{1}' o el hash, mientras la entrada no caduque. Los cambios que nunca tuvieron commit, no. Por eso el commit va antes de pedir.

¿Rama o worktree?

Para una tarea a la vez, una rama basta. Para varias sesiones del agente en paralelo, Claude Code tiene claude --worktree <nombre>, que crea un worktree de git con su propia rama; el repositorio necesita al menos un commit.

¿Cada cuánto hago commit?

Cada vez que las pruebas pasan y el cambio tiene sentido solo. Con un agente, eso suele ser después de cada pedido revisado. Es nuestra regla práctica, no una norma de git.

Checklist

  • git status limpio, o tu trabajo en un commit, antes de pedir.
  • Rama nueva con git switch -c agente/<tarea>.
  • Revisaste git status --short (incluidos los ??) y git diff.
  • Las pruebas pasan y ninguna prueba vieja cambió sin motivo.
  • Cada commit hace una cosa y su primera línea la resume en 50 caracteres o menos.
  • git reset --hard y git clean -f, solo en la rama del agente.
  • Integraste con git merge --ff-only y borraste la rama.

Con git en orden, el agente puede equivocarse sin costarte nada. Si lo que salió mal es un error, cómo reportarle un bug a la IA te dice qué pegar en el pedido, y lo que el agente debe saber de tu proyecto antes de empezar está en qué contexto necesita un agente de IA. Para revisar el plan antes de que toque archivos, usa plan mode en Claude Code, y el método completo está en mi flujo de 4 pasos con Claude Code.

¿Viste esto en Instagram? Comenta GIT en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 30 de octubre de 2026 · actualizado el 1 de noviembre de 2026

← Blog