Por qué conviene trabajar siempre en una rama propia
Cuando empiezas un repositorio nuevo, Git te deja en una única línea de historia, normalmente llamada main. Esa rama representa el estado “oficial” del proyecto: lo que se despliega, lo que revisa el resto del equipo y lo que debería compilar en todo momento. Si cada cambio se escribe directamente sobre ella, cualquier experimento a medias, cualquier corrección que rompe una prueba o cualquier idea que luego descartas queda mezclada con el trabajo estable. Las ramas existen precisamente para evitar eso.
Una rama en Git no es una copia de tus archivos, como suele imaginar quien viene de otras herramientas. Es un puntero ligero, un simple nombre que apunta a un commit. Crear una rama cuesta unos pocos bytes y tarda milisegundos, y por eso la práctica recomendada es abrir una nueva para cada tarea: una funcionalidad, un arreglo, una prueba de concepto o una actualización de dependencias. Cuando el trabajo está listo, se integra; cuando no sirve, se borra sin dejar rastro en la rama principal.
En este tutorial vas a aprender a crear ramas locales con las tres formas que existen hoy: git branch, git checkout -b y la más moderna, git switch -c. También verás cómo crear una rama desde un commit o una etiqueta concreta, cómo ponerles buenos nombres, qué errores aparecen con más frecuencia y cómo limpiar lo que ya no necesitas. Los ejemplos se probaron con la serie 2.56 de Git, la versión estable más reciente a fecha de este artículo, aunque todo lo que se explica funciona igual desde la 2.23, que fue la que introdujo git switch.
Si trabajas en equipo, la decisión de cuándo y cómo ramificar depende de la estrategia que hayáis acordado. Para eso te puede servir esta guía sobre cómo elegir un flujo de trabajo en Git según tu equipo, que complementa lo que veremos aquí, centrado en la mecánica de crear ramas en tu máquina.
Preparar un repositorio de práctica
Antes de tocar nada importante, conviene tener un entorno donde equivocarse sea gratis. Vamos a crear un proyecto pequeño, una libreta de recetas en texto plano, con un par de commits. Así los comandos tendrán algo real sobre lo que actuar.
mkdir libreta-recetas
cd libreta-recetas
git init -b main
La opción -b main en git init fija el nombre de la rama inicial. Si no la indicas, Git usará el valor de la configuración init.defaultBranch, y si tampoco existe, dependerá de la versión y de tu distribución. Puedes dejarlo establecido para siempre con este comando:
git config --global init.defaultBranch main
Comprueba también que Git sabe quién eres, porque sin identidad no podrás crear commits:
git config --global user.name "Tu Nombre"
git config --global user.email "[email protected]"
git --version
Ahora añade dos archivos y haz el primer commit:
echo "# Libreta de recetas" > README.md
echo "Tortilla de patatas: huevos, patatas, cebolla" > tortilla.txt
git add .
git commit -m "Primer commit con la tortilla"
Y un segundo commit, para que la historia tenga algo de recorrido:
echo "Gazpacho: tomate, pepino, pimiento, aceite" > gazpacho.txt
git add gazpacho.txt
git commit -m "Añade receta de gazpacho"
Con git log --oneline verás algo parecido a esto, aunque los identificadores serán distintos en tu equipo:
a91c3de (HEAD -> main) Añade receta de gazpacho
5b7f20c Primer commit con la tortilla
Fíjate en HEAD -> main. HEAD es el marcador que indica dónde estás ahora mismo, y en este momento apunta a la rama main. Entender esa relación entre HEAD, ramas y commits es la clave para no perderte después.
Qué es realmente una rama y qué pasa al crearla
Para crear ramas con confianza ayuda saber qué ocurre por dentro. Cada commit guarda una referencia a su commit padre. Una rama es un archivo diminuto dentro de la carpeta oculta del repositorio que contiene el identificador de un commit. Puedes comprobarlo tú mismo:
cat .git/refs/heads/main
La salida será el hash completo del último commit de main. Cuando haces un commit estando en esa rama, Git crea el commit nuevo y actualiza ese archivo para que apunte a él. Por eso se dice que la rama “avanza” sola.
Al crear una rama nueva, Git escribe otro archivo en esa carpeta con el mismo hash que tiene el commit de partida. Nada se copia: ambas ramas comparten toda la historia previa y solo divergen a partir del siguiente commit que hagas en cada una. Este diseño explica por qué es tan barato ramificar y por qué puedes tener decenas de ramas locales sin notar ningún coste en disco ni en rendimiento.
Existen dos acciones distintas que a menudo se confunden, y conviene separarlas mentalmente. La primera es crear la rama, es decir, añadir un nombre nuevo apuntando a un commit. La segunda es cambiar a ella, que significa mover HEAD para que los próximos commits se registren bajo ese nombre. Algunos comandos hacen solo lo primero y otros hacen las dos cosas a la vez. A continuación los repasamos uno por uno.
Crear una rama sin cambiarte a ella con git branch
El comando clásico y más explícito es git branch seguido del nombre. Crea el puntero, pero te deja donde estabas:
git branch receta-postres
No hay salida, y es normal: Git asume que si todo fue bien no tiene nada que decir. Para comprobar el resultado, lista las ramas locales:
git branch
* main
receta-postres
El asterisco indica la rama activa, es decir, aquella a la que apunta HEAD. Si ahora haces un commit, se registrará en main, no en la rama nueva. Este es un error muy habitual en quien está empezando: crear la rama, olvidar cambiarse y seguir trabajando sin darse cuenta en la rama equivocada.
Entonces, ¿cuándo tiene sentido usar git branch a secas? Principalmente en tres situaciones. La primera, cuando quieres dejar un marcador en el estado actual antes de hacer algo arriesgado, como una reescritura de historia, para poder volver si sale mal. La segunda, en scripts que preparan varias ramas de golpe sin moverse entre ellas. La tercera, cuando quieres crear una rama que apunte a otro commit distinto del actual, algo que veremos más adelante.
Para pasar a la rama recién creada, necesitas un segundo comando. Lo vemos en la siguiente sección.
Cambiar de rama con git switch y con git checkout
Una vez que la rama existe, puedes moverte a ella con dos comandos equivalentes para este caso. El moderno es git switch, que existe desde Git 2.23 y se diseñó con un único propósito: cambiar de rama.
git switch receta-postres
Switched to branch 'receta-postres'
Si tu Git está en español, el mensaje saldrá traducido, pero el significado es el mismo. El comando clásico, que hace lo mismo, es:
git checkout receta-postres
La diferencia no es de resultado, sino de diseño. git checkout es una navaja suiza: sirve para cambiar de rama, para restaurar archivos desde un commit, para situarte en un commit suelto y más cosas. Esa polivalencia lo hacía confuso, y por eso el proyecto lo dividió en git switch, para ramas, y git restore, para archivos. Ambos nacieron como experimentales; con el tiempo se consolidaron y hoy son los comandos recomendados en la documentación oficial. git checkout sigue funcionando y seguirá siendo necesario si te toca trabajar con Git antiguos o con scripts heredados.
Si quieres profundizar en todas las variantes de movimiento entre ramas, incluidas las opciones para volver a la anterior o para descartar cambios al moverte, tienes una guía dedicada sobre git switch y cómo cambiar de rama en Git que desarrolla ese tema por completo.
Un atajo útil: git switch - te lleva a la rama en la que estabas antes, igual que cd - en la terminal. Funciona también con git checkout -.
Crear y cambiar a la rama en un solo paso con git switch -c
Lo más habitual en el día a día es querer las dos cosas a la vez: abrir una rama y empezar a trabajar en ella. Con la forma moderna se escribe así:
git switch -c plato-del-dia
Switched to a new branch 'plato-del-dia'
La opción -c viene de “create”. Equivale a ejecutar git branch plato-del-dia seguido de git switch plato-del-dia, pero de forma atómica: si algo falla, no queda una rama a medias. Parte siempre del commit en el que estás ahora mismo, así que asegúrate de estar en la rama correcta antes de lanzarlo.
La variante clásica, que verás en tutoriales antiguos, en documentación de empresa y en la memoria muscular de media humanidad, es:
git checkout -b plato-del-dia
Ambos comandos producen exactamente el mismo resultado. Si ya tienes el hábito de escribir checkout -b, no hace falta que lo abandones de un día para otro, pero para equipos nuevos es preferible enseñar git switch -c, porque su nombre dice lo que hace y evita los efectos secundarios de checkout sobre archivos.
Comprueba el estado tras crearla:
git status
On branch plato-del-dia
nothing to commit, working tree clean
Y haz un primer commit en la rama para ver cómo diverge de main:
echo "Plato del día: lentejas con chorizo" > menu.txt
git add menu.txt
git commit -m "Añade el menú del día"
git log --oneline --graph --all
* c4e8b12 (HEAD -> plato-del-dia) Añade el menú del día
* a91c3de (main, receta-postres) Añade receta de gazpacho
* 5b7f20c Primer commit con la tortilla
Observa cómo plato-del-dia está un commit por delante, mientras que main y receta-postres siguen señalando el commit anterior. Esa es la divergencia en acción: tres nombres, dos commits distintos y ninguna copia de archivos.
Un resumen rápido de los tres caminos
Para que puedas consultarlo de un vistazo, estas son las equivalencias entre los comandos principales:
# Crear sin moverte
git branch nombre-rama
# Crear y moverte (forma moderna)
git switch -c nombre-rama
# Crear y moverte (forma clásica)
git checkout -b nombre-rama
# Moverte a una rama existente
git switch nombre-rama
git checkout nombre-rama
# Listar ramas locales
git branch
Hay una sutileza: con git switch no puedes usar un nombre de rama que no exista sin la opción -c, y recibirás un error. Con git checkout pasa algo parecido, pero hay un caso especial con ramas remotas del que hablaremos en la sección de errores.
Crear una rama a partir de un commit, una etiqueta u otra rama
Por defecto, una rama nueva nace en el commit donde está HEAD. Pero a menudo necesitas otro punto de partida: un arreglo urgente sobre la versión que ya se publicó, una investigación sobre un commit antiguo donde apareció un fallo, o una rama basada en otra que todavía no se ha integrado. Para ello, añade un segundo argumento con el punto de partida.
Desde un commit concreto, usando su hash abreviado:
git switch -c revision-tortilla 5b7f20c
Desde una etiqueta, útil para parchear una versión publicada:
git tag v1.0 5b7f20c
git switch -c parche-v1 v1.0
Desde otra rama, sin necesidad de estar situado en ella:
git switch -c ajuste-menu plato-del-dia
Desde el estado de hace unos commits, usando la notación relativa a HEAD:
git switch -c prueba-antigua HEAD~2
La sintaxis con git branch es la misma, solo que sin mover HEAD:
git branch copia-segura main
Y con git checkout -b:
git checkout -b revision-tortilla 5b7f20c
Un caso especialmente útil es rescatar un commit que parecía perdido. Si por accidente hiciste un git reset --hard o abandonaste commits estando en estado “detached HEAD”, puedes consultar el registro de movimientos con git reflog, localizar el hash y crear una rama que lo recupere:
git reflog
git switch -c rescate 9d3f1aa
Mientras Git no haya recogido esos objetos como basura, que suele tardar semanas, esa rama devolverá el trabajo a la vida. Es uno de los motivos por los que ramificar es una excelente red de seguridad antes de operaciones delicadas.
El estado detached HEAD y cómo convertirlo en una rama
Si te mueves a un commit o a una etiqueta sin crear rama, Git te avisa de que estás en un estado llamado “detached HEAD”. Por ejemplo:
git switch --detach 5b7f20c
o, con la forma clásica, git checkout 5b7f20c. En ese estado HEAD apunta directamente a un commit, no a una rama. Puedes mirar, probar e incluso hacer commits, pero esos commits no pertenecen a ninguna rama y, al cambiarte a otra, quedan huérfanos y acaban siendo recogidos por el recolector de basura.
La solución es sencilla: si decides que lo que hiciste merece conservarse, crea una rama allí mismo, sin moverte de sitio:
git switch -c experimento-desde-cero
Al hacerlo, la rama nace en el commit actual, incluyendo los commits que hubieras hecho estando “suelto”. Si el aviso te asusta, recuerda que no es un error, sino una advertencia informativa. De hecho, el uso de --detach es perfectamente legítimo para inspeccionar el pasado del proyecto sin comprometerse con una rama.
Cómo llevarte cambios sin confirmar a la rama nueva
Una situación frecuente: empiezas a editar archivos, de pronto te das cuenta de que estás en main y de que ese trabajo debería vivir en su propia rama. La buena noticia es que crear una rama no toca tu directorio de trabajo. Los cambios sin confirmar te acompañan:
git status
git switch -c ajustes-gazpacho
git status
Tras el cambio, git status mostrará los mismos archivos modificados, ahora bajo la rama nueva. Ya puedes añadirlos y hacer commit en el lugar adecuado, dejando main intacta. Esto funciona porque la rama nueva parte del mismo commit, de modo que no hay conflicto posible entre tus modificaciones y el contenido de partida.
El problema aparece cuando cambias a una rama existente cuyo contenido difiere del actual en archivos que tienes modificados. En ese caso Git se negará para no destruir tu trabajo. Tienes tres salidas razonables. La primera, hacer commit de lo que tienes. La segunda, guardarlo temporalmente:
git stash push -m "trabajo a medias del gazpacho"
git switch otra-rama
git stash pop
La tercera, descartar los cambios, algo que solo deberías hacer si estás completamente seguro. Para archivos concretos se usa git restore nombre-archivo; para forzar el cambio de rama descartando todo, git switch --discard-changes otra-rama, o git checkout -f otra-rama en la forma clásica. Úsalo con cuidado, porque no hay vuelta atrás para lo que no se ha confirmado.
Nombres de rama: convenciones que ahorran problemas
Git permite casi cualquier nombre, pero hay reglas y buenas costumbres. Entre las reglas técnicas: no puede contener espacios, ni los caracteres ~, ^, :, ?, *, [ ni la barra invertida; no puede empezar con un guion, terminar en una barra ni en .lock, ni incluir dos puntos seguidos. Puedes comprobar si un nombre es válido sin crear nada:
git check-ref-format --branch "arreglo/error-login"
Si el nombre es correcto, el comando lo repite y termina sin error. Si no, devuelve un mensaje de fallo.
En cuanto a las convenciones, la más extendida es usar un prefijo que indica el tipo de trabajo, separado por una barra, seguido de una descripción breve en minúsculas con guiones:
git switch -c funcionalidad/buscador-de-recetas
git switch -c arreglo/duplicados-en-menu
git switch -c docs/guia-de-contribucion
git switch -c refactor/separar-lectura-de-archivos
Los prefijos más comunes son funcionalidad o feature, arreglo o fix, hotfix para urgencias, docs, refactor, prueba o test y chore para tareas de mantenimiento. Muchos equipos añaden también el número de la incidencia, como en arreglo/482-duplicados-en-menu, lo que permite enlazar la rama con el gestor de tareas de forma automática.
Algunas recomendaciones prácticas adicionales:
- Usa minúsculas siempre. En sistemas con archivos insensibles a mayúsculas, como Windows y macOS por defecto, dos ramas que solo difieren en capitalización pueden provocar conflictos en las referencias.
- Describe el objetivo, no la persona. Un nombre como
arreglo/duplicados-en-menuinforma;rama-de-pedrono ayuda a nadie. - Evita nombres demasiado largos, porque aparecen truncados en muchas herramientas, y demasiado genéricos, como
pruebaocambios. - No reutilices el nombre de una rama que ya se integró y se borró, para no mezclar historias en el recuerdo del equipo.
- Ten cuidado con las barras: si existe una rama llamada
arreglo, no podrás creararreglo/algo, porque Git almacena las ramas como archivos y un archivo no puede ser a la vez carpeta.
Esa última limitación sorprende a más de uno. El error resultante sugiere que no se puede crear una referencia porque ya existe otra con un prefijo que choca. La solución es renombrar o borrar la rama que estorba.
Errores habituales al crear ramas y cómo resolverlos
A continuación, los tropiezos más frecuentes, con su causa y su arreglo.
Rama ya existente. Si repites un nombre, Git responde con un mensaje parecido a este:
fatal: a branch named 'plato-del-dia' already exists
La solución depende de la intención. Si querías ir a ella, usa git switch plato-del-dia sin la opción -c. Si quieres reiniciarla y que apunte al commit actual, existe git switch -C plato-del-dia, con la C mayúscula, que la crea o la restablece. Es una operación destructiva para esa rama en el sentido de que mueve su puntero, así que asegúrate de que no pierdes commits que no estén en otro sitio.
Crear la rama desde el punto equivocado. Si abres una rama desde main cuando debía partir de otra, no hace falta empezar de cero. Si aún no has hecho commits, borra la rama y vuelve a crearla. Si ya hiciste commits, puedes trasladarlos con git rebase --onto, una operación avanzada que conviene practicar antes en un repositorio de prueba.
Commits en la rama equivocada. Has creado la rama con git branch pero seguías en main y ya hiciste dos commits. Se arregla sin perder nada:
git branch trabajo-rescatado
git reset --hard HEAD~2
git switch trabajo-rescatado
Primero se marca el estado actual con la rama nueva, luego se retrocede main dos commits y por último te mueves a la rama que conserva el trabajo. Haz esto solo en ramas que no hayas publicado, porque reescribe el historial de main.
Rama sin commits previos. En un repositorio recién iniciado, sin ningún commit, intentar crear una rama falla, porque no hay un commit al que apuntar. Haz primero un commit inicial, o usa git switch --orphan nombre si de verdad quieres una rama sin historial previo.
Error por rama remota inexistente. Con git switch y un nombre que no existe localmente, Git busca una rama remota con ese nombre y, si la encuentra de forma inequívoca, crea una rama local que la sigue. Si no la encuentra, recibes:
fatal: invalid reference: nombre-que-no-existe
Casi siempre se trata de una errata. Revisa con git branch -a qué ramas locales y remotas conoce tu repositorio, y ejecuta git fetch si la rama es reciente y todavía no la has descargado.
Cambios que bloquean el cambio de rama. Ya lo vimos antes: si tienes archivos modificados que se verían afectados, Git se niega. Confirma, guarda con stash o descarta.
Confundir -c con -C y -b con -B. La minúscula crea y falla si existe; la mayúscula crea o reinicia. Un dedo en la tecla Mayús puede costarte un buen rato de git reflog para recuperar el puntero anterior.
Revisar, renombrar y entender el estado de tus ramas
Cuando acumulas ramas, necesitas formas de inspeccionarlas. El comando git branch admite varias opciones útiles. Con -v añade el último commit de cada rama:
git branch -v
main a91c3de Añade receta de gazpacho
* plato-del-dia c4e8b12 Añade el menú del día
receta-postres a91c3de Añade receta de gazpacho
Con --merged muestra las ramas cuyo contenido ya está incluido en la actual, que son candidatas a borrarse; con --no-merged, las que todavía tienen trabajo pendiente de integrar:
git branch --merged main
git branch --no-merged main
Para saber cuál es la rama activa sin listar todas, puedes usar:
git branch --show-current
Y si te equivocaste en el nombre, renómbrala sin perder nada. Si estás en ella, basta con indicar el nombre nuevo; si no, indica antiguo y nuevo:
git branch -m plato-del-dia menu-del-dia
git branch -m menu-del-dia carta-de-temporada
Si la rama ya estaba publicada en el remoto, renombrarla localmente no cambia el nombre allí; tendrás que publicar la nueva y eliminar la antigua. Por eso es mejor acertar el nombre antes de compartirla.
Otro detalle práctico es el prompt de la terminal. Muchas configuraciones de zsh o bash muestran la rama actual junto al directorio. Si la tuya no lo hace, instala o activa la integración que incluye Git en su carpeta de contribuciones, o usa un tema de terminal que lo haga. Ver siempre en qué rama estás previene la mayoría de los errores de la sección anterior.
De la rama local a la rama compartida
Todo lo anterior ocurre en tu equipo. Mientras no publiques, nadie más ve tus ramas, lo que te da total libertad para experimentar. Cuando quieras que otras personas las vean, revisen o continúen tu trabajo, tendrás que enviarla a un repositorio remoto. Se hace una vez con la opción que establece el seguimiento:
git push -u origin carta-de-temporada
La opción -u deja configurada la relación entre tu rama local y la remota, de modo que después basta con escribir git push y git pull. El proceso completo, con sus variantes y los problemas típicos al publicar, está desarrollado en el artículo sobre cómo publicar una nueva rama en Git con push de una rama local al remoto, que merece una lectura cuando des ese paso.
Hay también una configuración que ahorra el -u a quien lo olvida siempre. Si estableces la siguiente opción, el primer git push de una rama nueva creará la rama remota con el mismo nombre y dejará el seguimiento listo:
git config --global push.autoSetupRemote true
Para comprobar el estado del seguimiento de cada rama, mostrando cuánto se ha adelantado o atrasado respecto a su remota, usa git branch -vv.
Mantén una costumbre sana: antes de crear una rama para una tarea nueva, actualiza la rama base. Así partes de lo último y reduces los conflictos futuros.
git switch main
git pull
git switch -c funcionalidad/exportar-recetas
Esa secuencia de tres líneas es, probablemente, la que más repetirás a lo largo de tu carrera con Git.
Limpiar ramas que ya no necesitas
Ramificar es barato, pero acumular ramas muertas genera ruido y dificulta encontrar lo importante. Cuando una rama ya se integró, bórrala. Para eliminar una rama que está completamente fusionada, usa la opción en minúscula:
git branch -d receta-postres
Deleted branch receta-postres (was a91c3de).
Git protege tu trabajo: si la rama contiene commits que no están en ninguna otra, se negará y te explicará que no está totalmente fusionada. Si estás seguro de que quieres descartarla de todos modos, usa la mayúscula:
git branch -D experimento-desde-cero
No puedes borrar la rama en la que estás; primero cámbiate a otra. Y fíjate en el mensaje de salida, que incluye el hash del commit al que apuntaba. Si te arrepientes, puedes recrearla enseguida:
git switch -c experimento-desde-cero c4e8b12
Para limpiar en bloque las ramas ya fusionadas en main, excepto la propia main, puedes encadenar comandos. Revisa siempre la lista antes de borrar:
git branch --merged main
git branch --merged main | grep -v "main" | xargs git branch -d
Si la rama también existe en el remoto y quieres retirarla de allí, se hace con un comando aparte:
git push origin --delete carta-de-temporada
Y para que tu repositorio local deje de mostrar referencias a ramas remotas que otros ya eliminaron:
git fetch --prune
Una rutina de limpieza semanal o tras cada fusión mantiene el repositorio ordenado y evita que, meses después, nadie sepa si una rama antigua sigue viva.
Buenas prácticas para ramificar con criterio
Para cerrar la parte técnica, reunimos hábitos que marcan la diferencia entre usar ramas y usarlas bien.
- Una rama, un propósito. Si una rama mezcla un arreglo, una refactorización y una funcionalidad nueva, su revisión será larga y su reversión, dolorosa.
- Ramas de vida corta. Cuanto más tiempo vive una rama sin integrarse, más diverge de la base y más caros resultan los conflictos. Integra con frecuencia o actualiza tu rama con los cambios de la principal.
- Commits pequeños y con mensajes claros dentro de la rama. Luego será más sencillo revisarlos o deshacerlos selectivamente.
- Nunca trabajes directamente en la rama principal en proyectos compartidos. Muchos servicios permiten protegerla para impedirlo.
- Verifica dónde estás antes de crear. Un
git statusogit branch --show-currentrápido te asegura que el punto de partida es el que esperas. - Prefiere
git switch -cygit restoreagit checkoutpara el trabajo diario, y dejacheckoutpara entornos heredados. - Haz pruebas en un repositorio desechable cuando aprendas operaciones destructivas como
reset --hard,-Do-C. - Aprovecha los alias para abreviar lo repetitivo. Por ejemplo, este alias crea una rama desde la principal actualizada:
git config --global alias.nueva '!f() { git switch main && git pull && git switch -c "$1"; }; f'
git nueva funcionalidad/importar-csv
Con este tipo de automatización reduces la fricción y, sobre todo, evitas que el cansancio te lleve a crear una rama desde un punto equivocado.
Por último, recuerda que Git evoluciona de forma continua. La serie 2.56 es la estable más reciente en este momento, con revisiones de mantenimiento posteriores, y los comandos de este tutorial son parte estable de la interfaz desde hace años, así que no tienes que temer que queden obsoletos pronto. Aun así, git help switch y git help branch son tu mejor referencia local, siempre alineada con la versión que tienes instalada.
Conclusiones
Crear una rama local en Git es una operación sencilla y barata, y dominarla te da libertad para trabajar sin miedo. La rama es solo un puntero a un commit, de modo que puedes abrir tantas como necesites, probar ideas y descartar las que no funcionen sin afectar a la historia estable del proyecto.
Tienes tres caminos principales. git branch nombre crea sin moverte, útil para marcar un punto o para scripts. git switch -c nombre crea y te traslada en un solo paso, y es la opción moderna y recomendada. git checkout -b nombre hace lo mismo en la sintaxis clásica y sigue siendo válido. Si añades un segundo argumento, la rama nace en un commit, una etiqueta u otra rama concreta, lo que abre la puerta a parches sobre versiones publicadas y a la recuperación de trabajo perdido.
Cuida los nombres con prefijos claros y descripciones breves, comprueba siempre en qué rama estás antes de crear la siguiente y ten a mano las soluciones a los errores más comunes: ramas duplicadas, commits en el sitio equivocado y cambios sin confirmar que bloquean el movimiento. Cuando una rama cumpla su cometido, intégrala y bórrala con git branch -d, y mantén la limpieza como rutina.
Con estos fundamentos ya puedes avanzar hacia lo siguiente: publicar tus ramas, revisarlas con tu equipo y fusionarlas con confianza. Practica los ejemplos en un repositorio de pruebas hasta que escribir git switch -c sea tan natural como guardar un archivo.
