Home / Herramientas / Cómo elegir un flujo de trabajo en Git según tu equipo
Cómo elegir un flujo de trabajo en Git según tu equipo

Cómo elegir un flujo de trabajo en Git según tu equipo

16 November 2026 · 18 min de lectura ··

Por qué el flujo importa más que los comandos

Casi todo el mundo aprende Git empezando por los comandos: add, commit, push. Con eso se sobrevive en un proyecto personal, pero en cuanto aparece una segunda persona, un servidor de integración continua o un despliegue semanal, descubres que el problema ya no es recordar la sintaxis. El problema es ponerse de acuerdo sobre cuándo se crea una rama, quién puede tocar la rama principal, cómo se revisa el código y qué ocurre cuando algo falla en producción. A ese conjunto de acuerdos se le llama flujo de trabajo, y es lo que separa un repositorio ordenado de uno donde nadie se atreve a hacer git pull.

En este tutorial no vamos a repasar qué hace cada comando desde cero. Si necesitas ese punto de partida, puedes pasar antes por Comandos básicos de Git: Cómo usar Git en un proyecto real. Aquí partimos de que ya sabes confirmar cambios y subirlos, y lo que haremos es comparar cuatro formas de organizar el trabajo, ver en qué contexto encaja cada una y practicarlas con un proyecto de ejemplo: una pequeña aplicación de recetas de cocina llamada recetario.

Los ejemplos usan Git 2.56, la versión estable actual en el momento de escribir esto. Todo lo que verás funciona igual desde hace bastantes versiones, pero conviene usar las formas modernas: git switch para cambiar de rama en lugar del multiuso git checkout, y git restore para deshacer cambios en archivos. Si todavía dudas con el primero, tienes una explicación detallada en una guía sobre cambiar de rama con seguridad.

Preparar el escenario de práctica

Vamos a crear un repositorio local con un remoto simulado, de modo que puedas reproducir cada flujo sin depender de ninguna plataforma. Un repositorio “bare” funciona como servidor compartido: no tiene copia de trabajo, solo el historial.

mkdir laboratorio && cd laboratorio
git init --bare --initial-branch=main remoto.git
git clone remoto.git recetario
cd recetario
git config user.name "Marta Ibarra"
git config user.email "[email protected]"

Si quieres que todos tus repositorios nuevos usen main como rama inicial, ejecuta una sola vez git config --global init.defaultBranch main. Es una convención, no una obligación: algunos proyectos antiguos conservan master, y todo lo que veremos se aplica igual cambiando el nombre.

Creamos el primer commit con una estructura mínima:

mkdir src
printf "# Recetario\n" > README.md
printf "def listar():\n    return []\n" > src/recetas.py
git add .
git commit -m "Estructura inicial del recetario"
git push -u origin main

La opción -u enlaza la rama local con la remota, así que más adelante bastará con git push y git pull sin argumentos. Comprueba el resultado con git log --oneline --graph --all, un comando que usaremos mucho para visualizar cómo cambia el historial en cada flujo.

recetario/
├── README.md
└── src/
    └── recetas.py

Flujo uno: trabajar directamente sobre la rama principal

El flujo más simple es también el más honesto: una persona, un repositorio, una rama. Haces cambios, los confirmas y los subes. No hay revisión ni integración porque no hay nadie con quien integrar.

git switch main
printf "def buscar(nombre):\n    return [r for r in listar() if nombre in r]\n" >> src/recetas.py
git add src/recetas.py
git commit -m "Añade búsqueda por nombre"
git push

Este enfoque tiene ventajas reales. No pierdes tiempo gestionando ramas, el historial es lineal y fácil de leer, y para scripts personales o pruebas de concepto es suficiente. Sus límites aparecen rápido: si una tarea queda a medias, tu rama principal queda rota; si te equivocas, el error ya está subido; y si mañana entra un compañero, tendrás que cambiar de método sin transición.

Una variante útil para quien trabaja solo es usar ramas cortas locales y fusionarlas uno mismo. Sirve para aislar experimentos sin añadir burocracia:

git switch -c experimento-ingredientes
# ... varios commits de prueba ...
git switch main
git merge --no-ff experimento-ingredientes
git branch -d experimento-ingredientes
git push

La opción --no-ff obliga a crear un commit de fusión aunque Git podría avanzar la rama en línea recta. El resultado es que el grupo de commits del experimento queda reconocible en el historial, algo que agradecerás meses después al buscar cuándo entró cierta funcionalidad.

Flujo dos: ramas de funcionalidad y pull requests

Cuando hay dos o más personas, la regla pasa a ser que nadie escribe directamente en main. Cada tarea vive en su propia rama, se sube al remoto y se integra mediante una solicitud de revisión, conocida como pull request en GitHub o merge request en GitLab. Es el flujo dominante en equipos pequeños y medianos, y lo explico con detalle desde el punto de vista del trabajo en equipo en Guía para usar Git y GitHub en equipo como profesional.

El ciclo completo para una tarea, por ejemplo “permitir filtrar recetas por tiempo de preparación”, es este:

git switch main
git pull
git switch -c feat/filtro-tiempo

Antes de empezar actualizamos main. Parece una obviedad, pero partir de una base desactualizada es la causa número uno de conflictos evitables. Después editas, confirmas en pasos pequeños y subes:

printf "\ndef filtrar_por_tiempo(minutos):\n    return []\n" >> src/recetas.py
git add src/recetas.py
git commit -m "Esqueleto de filtrar_por_tiempo"
git push -u origin feat/filtro-tiempo

Al subir la rama, la plataforma suele mostrar un enlace para abrir la solicitud. Si prefieres la terminal y tienes instalada la CLI de GitHub, puedes hacerlo así:

gh pr create --base main --title "Filtro por tiempo de preparación" --body "Añade la función base y su primer test."

Mientras la revisión sigue abierta puedes seguir añadiendo commits a la misma rama; la solicitud se actualiza sola. Cuando alguien la aprueba, se fusiona desde la plataforma. Después vuelves a tu máquina y limpias:

git switch main
git pull
git branch -d feat/filtro-tiempo
git fetch --prune

git fetch --prune elimina las referencias locales a ramas remotas que ya no existen. Sin ese paso, git branch -r se llena de ramas fantasma. Conviene repetirlo con cierta frecuencia para mantener el repositorio ordenado.

Tres maneras de fusionar una pull request

Casi todas las plataformas ofrecen tres estrategias de integración, y elegir una influye en cómo se lee el historial durante años:

  • Merge commit: conserva todos los commits de la rama y añade un commit de fusión. El historial es fiel pero ramificado.
  • Squash: condensa la rama entera en un único commit en main. Queda limpio, a costa de perder los pasos intermedios.
  • Rebase: reaplica los commits de la rama sobre main sin commit de fusión. Es lineal y conserva cada commit, pero reescribe sus identificadores.

No hay una respuesta universal. El squash funciona muy bien cuando los commits intermedios son del tipo “arreglo”, “otro arreglo”, “ahora sí”. El merge commit es preferible cuando cada commit está cuidado y cuenta una historia. Lo importante es que el equipo elija una y la aplique de forma consistente.

Proteger la rama principal

Un flujo basado en revisión solo funciona si la plataforma impide saltárselo. En la configuración del repositorio puedes activar una regla de protección para main que exija, como mínimo, una aprobación antes de fusionar, que pasen las comprobaciones automáticas y que no se permita el envío forzado. Sin esto, el acuerdo depende de la buena voluntad de cada persona un viernes a las seis de la tarde.

Flujo tres: desarrollo sobre tronco con ramas muy cortas

El desarrollo sobre tronco (trunk-based development) lleva la idea de las ramas de funcionalidad a un extremo: las ramas existen, pero viven horas, no semanas. Cada persona integra en main al menos una vez al día. Para que esto no rompa nada se apoya en pruebas automáticas sólidas y en una técnica clave: los interruptores de funcionalidad, o feature flags.

La idea es separar “desplegar código” de “activar una funcionalidad”. Puedes fusionar una función incompleta si queda detrás de un interruptor apagado:

# src/config.py
FUNCIONES = {
    "filtro_tiempo": False,
}

# src/recetas.py
from config import FUNCIONES

def listar_recetas(minutos=None):
    base = listar()
    if FUNCIONES["filtro_tiempo"] and minutos is not None:
        return filtrar_por_tiempo(minutos)
    return base

Con esta estructura, la rama puede fusionarse el mismo día aunque filtrar_por_tiempo aún no esté terminada. Cuando esté lista y probada, un cambio de una sola línea la activa. Las ventajas son enormes: desaparecen las ramas longevas, los conflictos son pequeños porque las divergencias son mínimas y el despliegue se vuelve rutinario.

El coste es la disciplina. Necesitas una suite de pruebas rápida, una canalización de integración continua fiable y un equipo dispuesto a escribir cambios pequeños. Si tus pruebas tardan cuarenta minutos o fallan al azar, este flujo se convierte en una fuente de ansiedad. Para equipos que se están formando suele ser un destino al que se llega por etapas, no el punto de partida.

El comando que más se usa para mantener esas ramas cortas al día es el rebase interactivo ligero, que evita commits de fusión innecesarios al sincronizar:

git switch feat/cache-recetas
git fetch origin
git rebase origin/main

Si trabajas así habitualmente, puedes configurar que git pull haga rebase por defecto con git config --global pull.rebase true. Es una preferencia razonable, aunque conviene que todo el equipo la comparta, porque mezclar ambos estilos produce historiales confusos. Para entender a fondo las diferencias, consulta Git Merge y Git Rebase: Todo lo que necesitas saber.

Flujo cuatro: ramas apiladas para trabajo dependiente

A veces una tarea depende de otra que todavía no ha sido revisada. Imagina que Marta está añadiendo un sistema de etiquetas a las recetas y, sobre esa base, quiere construir el filtrado por etiqueta. Esperar a que la primera pull request se fusione bloquea todo; abrir una rama gigante hace la revisión inmanejable. La solución son las ramas apiladas: cada rama parte de la anterior.

git switch main && git pull
git switch -c feat/etiquetas-modelo
# commits del modelo de etiquetas
git push -u origin feat/etiquetas-modelo

git switch -c feat/etiquetas-filtro
# commits del filtro, que usa el modelo
git push -u origin feat/etiquetas-filtro

Después abres dos solicitudes. La primera apunta a main. La segunda apunta a feat/etiquetas-modelo, de modo que el revisor solo ve el diff propio del filtro, no el del modelo. Cuando la primera se fusiona, hay que reajustar la segunda para que apunte a main. Aquí aparece el momento delicado: si usaste squash al fusionar la primera, el historial de la segunda ya no encaja con main y necesitas un rebase con límite explícito.

git fetch origin
git rebase --onto origin/main feat/etiquetas-modelo feat/etiquetas-filtro
git push --force-with-lease

Lee la instrucción como “toma los commits que están entre feat/etiquetas-modelo y feat/etiquetas-filtro, y colócalos sobre origin/main”. Es la forma de decirle a Git que descarte los commits del modelo, que ya llegaron a main bajo otro identificador. Y fíjate en --force-with-lease: es la alternativa segura a --force, porque rechaza el envío si alguien más ha subido algo a esa rama que tú no has visto. Nunca uses el envío forzado a secas en una rama compartida.

Las ramas apiladas son potentes pero exigen cuidado. Mantén las pilas cortas, de dos o tres niveles como máximo, y fusiona de abajo hacia arriba sin retrasos. Si la pila crece, es señal de que la tarea original debía dividirse antes.

Hotfix y ramas de versión

Todo lo anterior supone que main siempre es lo que quieres desplegar. En productos con versiones soportadas en paralelo, como una librería o una aplicación móvil, la realidad es otra: la versión 2.3 está en producción, la 3.0 está a medio hacer, y aparece un fallo de seguridad en la 2.3.

La respuesta tradicional es una rama de versión y un flujo de corrección urgente:

git switch -c release/2.3 v2.3.0
git switch -c hotfix/validacion-ingredientes
# se corrige el fallo
git commit -am "Valida ingredientes vacíos"
git switch release/2.3
git merge --no-ff hotfix/validacion-ingredientes
git tag v2.3.1
git push origin release/2.3 v2.3.1

Después hay que llevar esa misma corrección a main para no reintroducir el fallo en la próxima versión. En lugar de fusionar la rama de versión completa, lo habitual es copiar solo el commit relevante con cherry-pick:

git switch main
git cherry-pick -x <identificador-del-commit>

La opción -x añade al mensaje una línea que indica de qué commit procede el cambio, lo que facilita auditar después qué correcciones viajaron a qué ramas. Si tu proyecto no mantiene varias versiones a la vez, no necesitas nada de esto; un hotfix será simplemente una rama de funcionalidad con prioridad alta.

Resolver conflictos sin miedo

Cualquier flujo con más de una persona produce conflictos tarde o temprano. Ocurren cuando dos ramas modifican las mismas líneas y Git no puede decidir cuál prevalece. Provoquemos uno a propósito para verlo con calma. En una rama cambiamos el nombre de una función, y en otra le añadimos un parámetro.

git switch -c feat/renombrar main
sed -i 's/def listar():/def obtener_todas():/' src/recetas.py
git commit -am "Renombra listar a obtener_todas"

git switch -c feat/paginar main
sed -i 's/def listar():/def listar(pagina=1):/' src/recetas.py
git commit -am "Añade paginación a listar"

git merge feat/renombrar

Git detiene la fusión y lo indica:

Auto-merging src/recetas.py
CONFLICT (content): Merge conflict in src/recetas.py
Automatic merge failed; fix conflicts and then commit the result.

Al abrir el archivo verás marcas como estas:

<<<<<<< HEAD
def listar(pagina=1):
=======
def obtener_todas():
>>>>>>> feat/renombrar
    return []

La parte superior es tu rama actual, la inferior es la que intentas fusionar. Tu tarea es dejar el código final correcto y eliminar las tres marcas. En este caso la resolución sensata combina ambos cambios:

def obtener_todas(pagina=1):
    return []

Después se marca como resuelto y se concluye la fusión:

git add src/recetas.py
git commit

Si en mitad del proceso te das cuenta de que has entrado en un callejón sin salida, git merge --abort te devuelve al estado anterior sin consecuencias. Para saber en qué estado estás, git status lista los archivos en conflicto bajo el epígrafe “Unmerged paths”.

Reducir la frecuencia de los conflictos

Resolver bien los conflictos es una habilidad, pero evitarlos es mejor estrategia. Estas prácticas hacen más por tu paz mental que cualquier herramienta:

  • Sincroniza tu rama con main a diario, no al final de la tarea.
  • Haz commits pequeños y cambios acotados; una rama de tres archivos rara vez conflictúa.
  • Evita reformatear archivos enteros junto con cambios funcionales. Un cambio de estilo toca todas las líneas y garantiza conflictos con cualquiera.
  • Comunica con el equipo cuando vayas a refactorizar algo transversal, como renombrar un módulo.
  • Acuerda un formateador automático común, para que el estilo no dependa del editor de cada persona.

Una herramienta menos conocida pero valiosa es git rerere, que significa “reutilizar resolución registrada”. Una vez activada con git config --global rerere.enabled true, Git recuerda cómo resolviste un conflicto concreto y lo aplica automáticamente si vuelve a aparecer, algo habitual cuando haces rebase repetido de una rama larga.

Mensajes de commit y tamaño de los cambios

Un flujo de trabajo no es solo estructura de ramas; también es la calidad de lo que viaja por ellas. Un historial legible convierte la revisión en una conversación y la depuración en una búsqueda rápida. Algunos principios prácticos:

  • La primera línea resume el cambio en unos cincuenta caracteres y usa un verbo en imperativo: “Añade”, “Corrige”, “Elimina”.
  • Si hace falta explicar el motivo, se deja una línea en blanco y se escribe un párrafo con el porqué, no con el cómo; el cómo ya está en el diff.
  • Cada commit debería compilar y pasar las pruebas por sí solo, para que git bisect pueda localizar regresiones sin tropiezos.
  • Una pull request razonable cabe en una sola revisión de unos veinte o treinta minutos. Si es más grande, divídela.

Algunos equipos adoptan una convención formal para los prefijos, como feat:, fix: o docs:, lo que permite generar registros de cambios automáticamente. No es imprescindible, pero ayuda cuando el repositorio crece.

Para que un cambio mal organizado no se quede en tu máquina antes de revisarlo, puedes reorganizar los commits locales con un rebase interactivo antes de subir la rama:

git rebase -i origin/main

En el editor que se abre puedes marcar commits con squash o fixup para agruparlos, o reword para corregir mensajes. Esto solo se hace sobre commits que aún no has compartido; reescribir historial público es la forma más rápida de ganarte enemigos.

Deshacer errores sin entrar en pánico

Cada flujo asume que cometerás errores, y Git ofrece una herramienta distinta según el momento en que los detectes. Conviene conocer la tabla mental completa:

# Cambios en el directorio de trabajo que aún no has añadido
git restore src/recetas.py

# Archivo añadido al área de preparación por error
git restore --staged src/recetas.py

# Último commit local con mensaje equivocado
git commit --amend

# Commit ya compartido que hay que anular sin reescribir historia
git revert <identificador>

# Recuperar algo que parecía perdido
git reflog

La diferencia entre revert y reset es esencial en un flujo colaborativo. git revert crea un commit nuevo que deshace otro, de modo que el historial sigue creciendo hacia delante y nadie tiene que rehacer nada. git reset mueve la rama hacia atrás y solo es seguro sobre commits locales. Y si alguna vez crees haber perdido trabajo tras un reset o un rebase fallido, git reflog guarda el rastro de dónde ha estado HEAD durante las últimas semanas; casi siempre hay una salida.

Practica estos comandos en un repositorio de prueba antes de necesitarlos de verdad.

Integración continua como parte del flujo

Un flujo moderno incluye una canalización automática que valida cada rama antes de fusionarla. En GitHub se define con un archivo YAML dentro de .github/workflows. Este ejemplo ejecuta las pruebas de Python en cada pull request dirigida a main:

name: pruebas
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
      - run: pip install pytest
      - run: pytest

Combinada con la protección de rama, esta comprobación convierte las pruebas en un requisito real: si fallan, el botón de fusionar permanece bloqueado. Revisa las versiones de las acciones que uses en cada momento, porque se publican nuevas con regularidad y las antiguas acaban siendo retiradas.

Además de las pruebas, merece la pena automatizar el formato y el análisis estático, y un archivo CODEOWNERS que asigne revisores según la carpeta modificada. Así, los cambios en la parte de pagos van automáticamente a la persona que mejor la conoce.

Cómo decidir qué flujo usar

Con las cuatro opciones sobre la mesa, la elección depende de factores concretos y no de modas. Estas preguntas te ayudan a decidir:

  • Cuántas personas escriben en el repositorio. Con una sola, el flujo directo basta; con varias, necesitas ramas y revisión.
  • Cada cuánto despliegas. Si lo haces varias veces al día, el desarrollo sobre tronco encaja; si publicas versiones numeradas, necesitarás ramas de versión.
  • Cuánta confianza tienes en tus pruebas. Cuanto más sólidas, más corta puede ser la vida de una rama y más ligera la revisión.
  • Si hay requisitos de auditoría. Sectores regulados suelen exigir aprobaciones registradas, lo que favorece las pull requests con protección de rama.
  • Qué experiencia tiene el equipo. Un grupo con poca práctica en Git se beneficia de un flujo simple y estricto antes que de uno sofisticado.

Una guía rápida para quienes empiezan: usa ramas de funcionalidad con pull requests y fusión mediante squash, protege main, activa la integración continua y revisa cada seis meses si el proceso te estorba. A partir de ahí, ajusta. Es mucho más fácil acortar ramas que acostumbrarse a ellas tras años de rama única.

Errores frecuentes al adoptar un flujo

Después de ver equipos pasar por estas transiciones, los fallos suelen repetirse. Reconocerlos a tiempo evita muchos disgustos.

  • Ramas que viven semanas. Cuanto más tiempo pasa, más diverge del tronco y más doloroso es integrarla. Si una tarea es grande, divídela o usa interruptores de funcionalidad.
  • Commits gigantes con mensajes vagos como “cambios varios”. Dificultan la revisión y hacen imposible localizar una regresión.
  • Subir secretos al repositorio. Una vez enviada una clave, borrarla en un commit posterior no basta, porque sigue en el historial. Hay que revocarla y rotarla.
  • Forzar el envío sobre ramas compartidas. Si necesitas reescribir una rama, avisa y usa siempre --force-with-lease.
  • Fusionar sin leer el diff. La revisión se convierte en un trámite y pierde su valor.
  • Cambiar de flujo sin comunicarlo. Mezclar rebase y merge, o squash y merge commit, genera un historial incoherente.
  • Olvidar limpiar. Ramas fusionadas que se acumulan en el remoto son ruido; activa la opción de borrado automático tras la fusión.

Un último consejo práctico: documenta el flujo elegido en un archivo CONTRIBUTING.md en la raíz del repositorio. Debe responder, en media página, cómo se nombran las ramas, cómo se redactan los mensajes, qué estrategia de fusión se usa y quién revisa qué. Los nuevos miembros lo agradecerán, y tú también cuando vuelvas a un proyecto tras unos meses.

Una sesión completa de principio a fin

Para cerrar el círculo, repasemos un día típico en el proyecto de recetas usando el flujo recomendado. Llega la tarea “mostrar el tiempo total en la lista de recetas”.

git switch main
git pull
git switch -c feat/tiempo-total

Escribes el código, ejecutas las pruebas en local y confirmas en dos pasos lógicos:

git add src/recetas.py
git commit -m "Calcula el tiempo total de preparación"
git add tests/test_recetas.py
git commit -m "Prueba el cálculo del tiempo total"

Antes de subir, compruebas que no te has quedado atrás respecto a main:

git fetch origin
git rebase origin/main
git push -u origin feat/tiempo-total

Abres la solicitud, recibes dos comentarios, corriges y subes un commit más. Cuando se aprueba y se fusiona con squash, regresas:

git switch main
git pull
git branch -d feat/tiempo-total
git log --oneline -n 5

Fíjate en que git branch -d puede negarse a borrar la rama si fusionaste con squash, porque Git no reconoce los commits originales como incluidos en main. En ese caso, y solo después de confirmar que la solicitud está fusionada, usa git branch -D feat/tiempo-total. Es uno de esos detalles que desconciertan a quien empieza y que conviene conocer de antemano.

Conclusiones

No existe un flujo de trabajo en Git que sea correcto para todos los equipos; existe el que encaja con tu tamaño, tu frecuencia de despliegue y la confianza que tengas en tus pruebas. Trabajar directamente sobre la rama principal vale para proyectos personales, las ramas de funcionalidad con pull requests son el punto de partida más sensato para equipos, el desarrollo sobre tronco recompensa a quienes ya dominan la automatización, y las ramas de versión con hotfix resuelven el caso de varias versiones en paralelo.

Sea cual sea tu elección, hay principios que se repiten: ramas cortas, commits pequeños con buenos mensajes, sincronización frecuente con la rama principal, protección de main y pruebas automáticas como red de seguridad. Añade a eso un conocimiento sólido de las herramientas de rescate, como reflog, revert y --force-with-lease, y los errores dejarán de dar miedo. Elige un flujo, escríbelo en un documento, aplícalo con constancia y revísalo cuando el equipo crezca. Si quieres seguir profundizando, el siguiente paso natural es practicar cada flujo en un repositorio de pruebas hasta que los comandos salgan solos.