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)
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
--shortda 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(+)
git add -Apasa al stage todo el árbol: archivos nuevos, cambiados y borrados (git add).git commit -mcrea el commit con ese mensaje (git commit).- La salida dice la rama, el hash corto y el resumen.
7994890es 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).
git switch mainvuelve a la rama principal.- git merge
--ff-onlyintegra solo si puede avanzarmainhasta el último commit de la rama sin crear un commit de merge. Simainavanzó por otro lado, se niega y termina con error, y tú decides qué hacer. - git branch
-dborra 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).
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;
}
- Las líneas con
+son nuevas, las de-se quitaron y las demás son contexto. - El primer bloque (
@@ -1,6 +1,7 @@) agrega unconsole.logenagregarLinea. Nadie lo pidió: es depuración que se quedó. - 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.
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ón | Comando | Qué pierdes |
|---|---|---|
| Un archivo quedó mal | git restore <archivo> | Los cambios sin commit de ese archivo |
| Pasaste algo al stage por error | git restore --staged <archivo> | Nada: el cambio sigue en el archivo |
| Todo el intento salió mal | git reset --hard | Todos los cambios sin commit de los archivos que git sigue |
| Quedaron archivos nuevos | git clean -n y luego git clean -f | Los archivos que git no sigue |
| El commit del agente sobra | git reset --hard <commit> | Los commits posteriores, recuperables con git reflog |
| Ya lo compartiste | git 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
- 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. - git reset
--hardsin commit usaHEAD: deja archivos y stage como en el último commit. - El archivo nuevo sobrevivió al reset:
git reset --hardno se ocupa de los archivos que git no sigue. - git clean
-nmuestra qué borraría, sin borrar.-fborra. Sin-f, git se niega por defecto. Si el agente creó carpetas, agrega-d:git clean -ndygit 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 congit reflog. Úsalo solo en la rama de trabajo del agente, después de mirargit 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
git reset --hard 7994890mueve la rama al punto seguro y deja los archivos como estaban ahí.git reflog -3muestra los últimos tres movimientos.HEAD@{0}es donde estás;HEAD@{1}, el movimiento anterior.'HEAD@{1}'va entre comillas: en PowerShell, sin ellas, el comando falla. En bash y zsh funciona igual con o sin comillas.- 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
git restore --stagedsaca el archivo del stage; el cambio sigue en el archivo.git add -penseña cada bloque del diff y pregunta. Respondimosnal primero (elconsole.log) yyal segundo (el descuento). Las otras respuestas útiles:qpara salir yspara dividir un bloque, cuando se puede.- El stage ya marca
4 +++-en lugar de5 ++++-: elconsole.logse quedó fuera. git restore src/carrito.jsdescarta lo que no entró al commit. Como restaura desde el stage, que ya es igual al commit, el descuento se queda y elconsole.logse va.git status --shortsin 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
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??engit status. - Usar
git reset --hardsin mirar antes. Ungit statusde 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 statuslimpio, o tu trabajo en un commit, antes de pedir.- Rama nueva con
git switch -c agente/<tarea>. - Revisaste
git status --short(incluidos los??) ygit 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 --hardygit clean -f, solo en la rama del agente.- Integraste con
git merge --ff-onlyy 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

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