Nivel inicial13 min de lectura · Publicado el

Git Flow: qué es, ramas y comandos (y cuándo no usarlo)

Git Flow: esquema de ramas; feature vuelve a develop, release sale de develop y va a main y a develop, y hotfix sale de main y vuelve a las dos. Git Flow: dos ramas fijasrubentejera.com mainhotfixreleasedevelopfeature
La rama main guarda lo que está en producción y develop, la próxima versión: son las dos ramas fijas. feature sale de develop y vuelve a ella; release sale de develop y se fusiona en main y en develop; hotfix sale de main y vuelve a las dos.

¿Qué es Git Flow?

A lo largo de la jornada ejecutamos muchas veces los mismos comandos de Git: checkout, merge, push, pull, crear ramas y borrarlas. Git Flow (también escrito gitflow o git-flow) pone orden en todo eso: es un modelo de ramas que dice qué ramas usar, de dónde sale cada una y dónde se fusiona.

El nombre se usa para dos cosas distintas:

  • El modelo de ramas. Lo publicó Vincent Driessen en 2010 en el artículo «A successful Git branching model». Dice qué ramas existen, de dónde sale cada una y dónde se fusiona.
  • La herramienta git-flow. Es un conjunto de extensiones de Git que aplican ese modelo con un solo comando. En lugar de crear la rama, cambiarte a ella, fusionarla y borrarla a mano, escribes git flow feature finish y lo hace por ti.

Piensa en la cocina de un restaurante. Lo que sale a la sala tiene que estar perfecto (main). En la mesa de trabajo se preparan los platos del próximo menú (develop). Cada cocinero prepara su parte en su propia tabla (feature), antes de servir hay un último repaso en el pase (release), y si a un cliente le llega un plato mal, se rehace al momento sin esperar al menú siguiente (hotfix). El símil se queda corto en una cosa: en Git las «tablas» pueden durar semanas, y cuanto más duran, más cuesta juntarlas después.

Ramas en Git Flow

Diagrama del modelo Git Flow: el tiempo avanza hacia abajo; las ramas feature salen de develop y vuelven a develop; una rama release sale de develop y se fusiona en master con la etiqueta 1.0; un hotfix sale de master, se etiqueta como 0.2 y se incorpora también a develop

Diagrama: «A successful Git branching model», de Vincent Driessen, con licencia CC BY-SA 4.0. Sin modificaciones. En el diagrama original la rama de producción se llama master.

Hay dos ramas que viven siempre y cuatro de apoyo que se crean y se borran. Cómo listarlas y limpiar las que ya no hacen falta, en ramas locales en Git.

Las dos ramas principales

main (antes master). Todo lo que hay aquí está listo para producción. Cada vez que se incorpora código a main, por definición, hay una nueva versión, y se marca con una etiqueta (tag) como 1.0.0.

develop. Contiene el código que formará la siguiente versión planificada. Es donde se juntan las funcionalidades terminadas.

Las ramas de apoyo

Rama Para qué sirve Sale de Se fusiona en Nombre
feature Una funcionalidad nueva develop develop feature/<nombre>
release Preparar una versión: últimos ajustes y correcciones develop main y develop release/<versión>
hotfix Corregir un fallo urgente en producción main main y develop hotfix/<versión>
support Mantener una versión antigua que aún se usa main o una etiqueta No vuelve a fusionarse de forma automática support/<nombre>

Algunos detalles que conviene saber:

  • Feature. Puede llamarse como quieras, salvo con los nombres de las demás ramas. Mientras dura, nadie toca develop por ti.
  • Release. En ella solo se corrigen fallos y se ajusta lo necesario para publicar (por ejemplo, el número de versión). Las funcionalidades nuevas esperan a la siguiente versión.
  • Hotfix. Es como una release, pero sin planificar. Driessen añade una excepción: si en ese momento hay una rama release abierta, el hotfix se fusiona en esa release en lugar de en develop, porque la release acabará llegando a develop.
  • Support. El artículo de Driessen no la incluye: la añadieron las herramientas. Sirve para mantener versiones antiguas que todavía están en uso, por ejemplo una 1.x mientras el resto avanza en la 2.x. Si solo tienes una versión en producción, no la necesitas.
  • Los nombres. Driessen usaba guion (release-1.2, hotfix-1.2.1). Las herramientas usan prefijos con barra (release/1.2, hotfix/1.2.1), que muchas interfaces muestran como carpetas.

Instalar git-flow

La herramienta original de Driessen (nvie/gitflow) está archivada desde octubre de 2025 y su página remite a git-flow-next, una reescritura en Go mantenida por Tower, la empresa del cliente de Git del mismo nombre. La versión más popular durante años, git-flow (AVH Edition), está archivada desde junio de 2023.

Sistema Comando Qué instala
macOS y Linux con Homebrew brew install git-flow-next git-flow-next
Windows winget install GitTower.GitFlowNext o scoop install git-flow-next git-flow-next
Linux sin Homebrew Descarga el binario de su página de versiones (ver abajo) git-flow-next
Debian y Ubuntu sudo apt install git-flow AVH Edition 1.12.3, sin mantenimiento

En Linux sin Homebrew, descarga el binario y cópialo a una carpeta del PATH (cambia v2.1.0 por la última versión y amd64 por arm64 si tu equipo es ARM):

curl -sL https://github.com/gittower/git-flow-next/releases/download/v2.1.0/git-flow-next-v2.1.0-linux-amd64.tar.gz | tar xz -C /tmp
sudo install /tmp/git-flow /usr/local/bin/git-flow
git flow version   # 2.1.0 (git-flow-next)

Cómo usar git-flow: los comandos

Los ejemplos están ejecutados con git-flow-next 2.1.0. Con la AVH Edition los comandos son los mismos; cambian los mensajes y la rama se llama master.

  1. Inicializa el repositorio una vez: git flow init.
  2. Para cada funcionalidad: feature start, tus commits y feature finish.
  3. Para publicar una versión: release start y release finish.
  4. Para un fallo urgente en producción: hotfix start y hotfix finish.

Inicializar un proyecto con git flow init

mkdir nombre-proyecto
cd nombre-proyecto
git init
git flow init --defaults

--defaults (o -d) acepta los nombres por defecto sin preguntar. Sin esa opción, git flow init te pregunta uno a uno los nombres de las ramas y los prefijos; si pulsas Enter en todos, el resultado es el mismo.

Initializing git-flow with default settings
Created branch 'main'
Created branch 'develop'
Git flow has been initialized

Este comando hace por ti:

  • Crea la rama main (master en la AVH Edition).
  • Crea la rama develop.
  • Te deja en la rama develop.
  • Guarda los nombres y prefijos en la configuración del repositorio (.git/config).

Empezar una feature: git flow feature start

git flow feature start login
Created branch 'feature/login' from 'develop'

Crea la rama feature/login a partir de develop y te cambia a ella. Ahora trabajas con normalidad: editas, haces git add y git commit las veces que haga falta.

Terminar una feature: git flow feature finish

git flow feature finish login

Este comando hace por ti:

  • Fusiona la rama feature/login en develop.
  • Borra la rama feature/login.
  • Te deja en la rama develop.

Así lo resume la AVH Edition:

Summary of actions:
- The feature branch 'feature/newfeature' was merged into 'develop'
- Feature branch 'feature/newfeature' has been locally deleted
- You are now on branch 'develop'

Si estás en la propia rama de la feature, basta con git flow finish: git-flow-next detecta qué rama es.

Publicar una versión: git flow release

git flow release start 1.0.0
# ajusta el número de versión, corrige los últimos fallos y haz commit
git flow release finish -m "Versión 1.0.0" 1.0.0

release finish fusiona la rama release/1.0.0 en main, crea la etiqueta 1.0.0 con el mensaje que indicas en -m, lleva esos cambios a develop, borra la rama de la release y te deja en develop.

Qué es un hotfix y cómo se hace: git flow hotfix

Un hotfix es la vía rápida para arreglar algo que ya está en producción, sin arrastrar lo que aún está a medias en develop:

git flow hotfix start 1.0.1
# corrige el fallo y haz commit
git flow hotfix finish -m "Versión 1.0.1" 1.0.1

La rama sale de main. Al terminar, se fusiona en main, se crea la etiqueta 1.0.1 y la corrección llega también a develop, para que el fallo no reaparezca en la siguiente versión.

Chuleta de comandos

Quiero… Comando
Preparar el repositorio git flow init --defaults
Empezar una funcionalidad git flow feature start <nombre>
Subirla al remoto para compartirla git flow feature publish <nombre>
Terminarla git flow feature finish <nombre>
Ver las features abiertas git flow feature list
Preparar una versión git flow release start <versión>
Publicarla con etiqueta git flow release finish -m "<mensaje>" <versión>
Arreglar producción git flow hotfix start <versión> y git flow hotfix finish <versión>
Mantener una versión antigua git flow support start <nombre> <etiqueta>

Cuándo no usar Git Flow

No hay soluciones mágicas: mira tu contexto.

En 2020, diez años después de publicarlo, Driessen añadió una «nota de reflexión» al principio de su artículo. En resumen, dice esto:

  • Git Flow se hizo tan popular que muchos equipos lo tratan como un estándar, y también, por desgracia, como un dogma o una solución para todo.
  • Hoy se desarrollan sobre todo aplicaciones web, que se entregan de forma continua, no se vuelven a versiones anteriores y no obligan a mantener varias versiones a la vez. No es el tipo de software que él tenía en mente.
  • Si tu equipo hace entrega continua, recomienda un flujo mucho más simple, como GitHub flow, en lugar de forzar Git Flow.
  • Si tu software tiene versiones explícitas o necesitas mantener varias versiones en uso, Git Flow puede seguir encajando tan bien como siempre.
  • Y termina: no hay panaceas; considera tu contexto y decide por ti mismo.

Martin Fowler, en «Patterns for Managing Source Code Branches», añade un matiz útil: Git Flow no dice cuánto deben durar las ramas feature, y por tanto tampoco cada cuánto se integra el trabajo. Cuanto más vive una rama separada, más cambios se acumulan y más difícil es juntarla después.

Git Flow encaja si…

  • Publicas versiones numeradas cada cierto tiempo
  • Mantienes varias versiones a la vez (por ejemplo, software instalado en casa de cada cliente)
  • Necesitas una fase de preparación antes de cada versión

Mejor algo más simple si…

  • Despliegas a producción varias veces por semana o al día
  • Solo hay una versión en producción, como en la mayoría de webs
  • Tus features viven semanas y fusionarlas siempre da conflictos

Las alternativas: GitHub flow y trunk-based development

  • GitHub flow. Una sola rama principal y ramas cortas para cada cambio. Abres una pull request, alguien la revisa, pasan las comprobaciones automáticas y se fusiona en la rama principal. Sin develop, sin release y sin hotfix: un arreglo urgente es un cambio más.
  • Trunk-based development (desarrollo sobre el tronco). Todo el equipo integra en la rama principal (el «tronco») muy a menudo. Según la guía del programa de investigación DORA, eso significa tres o menos ramas activas, ramas que duran horas y no días, y fusionar en el tronco al menos una vez al día. DORA relaciona estas prácticas con un mejor rendimiento en la entrega de software.

Las dos se apoyan en la integración continua: cada cambio se junta pronto con el de los demás y una batería de tests automáticos confirma que nada se ha roto. Sin tests fiables, integrar a diario da miedo, y las ramas largas vuelven a parecer la opción segura. Por eso estas alternativas van de la mano de prácticas como el TDD. Tienes más contexto en Desarrollo continuo de software.

git-flow-next también contempla estos flujos: git flow init --preset=github configura una rama principal con ramas feature, sin develop.

Tu siguiente paso

  • Si publicas versiones numeradas, prueba Git Flow en un repositorio de juguete: git flow init --defaults, una feature y una release. En cinco minutos verás todo el ciclo.
  • Si despliegas de forma continua, empieza por ramas cortas que se fusionen en el día, y deja Git Flow para cuando de verdad necesites mantener varias versiones.
  • En ambos casos, unos mensajes de commit consistentes hacen el historial mucho más fácil de leer: te lo cuento en Git Commitizen.

Para seguir aprendiendo

Fuentes

Comprobado en noviembre de 2026:

Ejecutado en contenedores Docker debian:trixie con Git 2.47.3: git flow init --defaults, --preset=classic, feature start/finish (con y sin --no-ff), feature list, release start/finish -m, hotfix start/finish y support start con git-flow-next 2.1.0 (binario linux-amd64 de su página de versiones), y git flow init -d, feature start/finish y release start/finish con git-flow AVH Edition 1.12.3 (paquete de Debian). La instalación con Homebrew, WinGet y Scoop se ha comprobado solo en la documentación oficial. La captura de feature finish es la del artículo original de Rubén.