¿Cómo usar ramas en Git para organizar tu trabajo?

Las ramas en Git son líneas de desarrollo independientes que te permiten trabajar en nuevas funciones sin tocar el código principal.

¿Qué es una rama?

Una rama (branch) es una copia del historial de tu proyecto en un punto específico. Puedes editarla libremente sin afectar la rama principal.

Imagina que trabajas en el sitio web de Liverpool. La rama principal tiene el código que los clientes ya usan. Si quieres agregar un nuevo módulo de pagos, creas una rama separada para desarrollarlo con seguridad.

La rama principal: main

Cuando ejecutas git init, Git crea automáticamente una rama llamada main (o master en versiones anteriores). Todo tu trabajo inicial vive ahí.

main representa el código estable de tu proyecto. El equipo evita hacer cambios experimentales directamente en ella.

Estructura de los comandos principales

Antes de ver ejemplos, revisa los comandos esenciales para trabajar con ramas:

El asterisco (*) en la salida de git branch señala la rama donde estás ahora mismo.

Cómo crear y usar una rama: tres ejemplos

Ejemplo 1 — Rama para una función nueva

Supón que trabajas en una app de recursos humanos para Bimbo. Quieres agregar el módulo de cálculo de nómina sin romper el sistema actual.

# Estás en main
git branch modulo-nomina
git switch modulo-nomina

Ahora editas los archivos de nómina, haces tus commits y main permanece intacta. El equipo puede seguir trabajando en main al mismo tiempo.

# Confirmas los cambios en la rama nueva
git add calculo_nomina.py
git commit -m "Agrega función para calcular salario neto"

Ejemplo 2 — Crear y cambiar en un solo comando

El comando git switch -c combina los dos pasos anteriores. Es la forma más rápida de empezar una rama.

Supón que eres desarrollador en FEMSA y necesitas corregir un error en el módulo de inventario:

git switch -c fix-inventario

Esto crea la rama fix-inventario y te cambia a ella de inmediato. Después trabajas, haces commits y el error queda aislado del resto del código.

Ejemplo 3 — Mover cambios terminados de vuelta a main

Cuando tu función está lista, necesitas integrarla a main. Para eso usas git merge.

# Regresa a main primero
git switch main

# Integra los cambios de tu rama
git merge modulo-nomina

Git combina el historial de modulo-nomina con main. Si no hay conflictos, la integración ocurre automáticamente.

Cómo se ve el historial con ramas

Usa git log --oneline --graph para visualizar las ramas y sus commits:

* 4f3a1bc (HEAD -> main, modulo-nomina) Agrega función para calcular salario neto
* 9d2e07f Estructura inicial del proyecto
* 1a8c334 Primer commit: configuración base

La etiqueta HEAD indica en qué rama y commit estás parado en este momento.

Por qué las ramas protegen tu código principal

Trabajar directamente en main es arriesgado. Si algo falla, el código roto llega a todos los colaboradores de inmediato.

Con ramas, cada función o corrección vive en su propio espacio. Solo cuando el trabajo está probado y aprobado se integra a main.

En equipos reales de empresas como Mercado Libre, cada programador trabaja en su propia rama. Nadie toca main directamente. Esa disciplina mantiene el producto estable.

Convenciones de nombres para ramas

Usar nombres descriptivos hace que el equipo entienda el propósito de cada rama de un vistazo.

Esta convención es estándar en equipos profesionales. Adóptala desde el principio.

Errores comunes al trabajar con ramas

Error 1 — Olvidar cambiar de rama antes de editar

Es fácil editar archivos sin darte cuenta de que sigues en main. Siempre verifica en qué rama estás con:

git branch --show-current

O con git status, que también muestra la rama actual en la primera línea.

Error 2 — Commits en la rama equivocada

Si hiciste cambios en main sin querer, aún puedes moverlos. Crea la rama correcta antes de hacer git reset. Esta situación es más fácil de prevenir que de resolver.

El hábito correcto: crea la rama primero, edita después.

Error 3 — Eliminar una rama con trabajo sin integrar

El comando git branch -d solo elimina ramas que ya se integraron a main. Si intentas borrar una rama con commits sin integrar, Git te avisa:

error: The branch 'fix-inventario' is not fully merged.

Eso es una protección. No uses -D (mayúscula) para forzar el borrado a menos que estés completamente seguro de que no necesitas esos cambios.

Error 4 — Nombres de ramas con espacios o caracteres especiales

Git no acepta espacios en los nombres de ramas. Usa guiones (-) o guiones bajos (_) en lugar de espacios.

# Incorrecto
git branch modulo nomina

# Correcto
git branch modulo-nomina

Flujo completo con ramas: resumen visual

main:           A --- B --------------------> M
                           \                /
modulo-nomina:              C --- D --- E --

• A y B son commits en main.
• En B creas la rama modulo-nomina.
• C, D y E son tus commits de desarrollo.
• M es el commit de merge: los cambios regresan a main.

Este flujo es la base de estrategias profesionales como Git Flow y GitHub Flow, que usan equipos en todo México y el mundo.

Ramas y trabajo en equipo

Cada integrante del equipo tiene su propia rama. No se pisan el trabajo. Cuando alguien termina, solicita una revisión (pull request) antes de integrar a main.

Esta práctica reduce errores en producción. Un bug que llega a main sin revisión puede costar horas de trabajo y afectar a miles de usuarios, como en cualquier aplicación de e-commerce de Mercado Libre.

Puntos clave

• Las ramas son independientes entre sí. Los cambios en una no afectan a las demás hasta que haces un merge.
• Siempre verifica en qué rama estás antes de editar con git branch --show-current o git status.
• git switch -c nombre-rama es el atajo para crear y cambiar de rama en un solo paso.
• Usa nombres descriptivos con prefijos como feature/, fix/ o hotfix/ para que tu equipo entienda el propósito de cada rama.
• Nunca trabajes directamente en main. Esa disciplina protege el código estable de tu proyecto.