Guía de autoevaluación de Git: repositorios, ramas y colaboración

Última actualización: 21 de noviembre de 2026
  • Comprender que Git guarda instantáneas completas y permite trabajar en local con un historial íntegro.
  • Saber mover cambios entre directorio de trabajo, área de preparación y repositorio mediante comandos básicos.
  • Resolver ramas, fusiones y conflictos sin sobrescribir el trabajo ajeno ni perder cambios propios.
  • Colaborar en GitHub con remotos, incidencias, pull requests, revisiones, etiquetas y liberaciones.

Programador utilizando una herramienta de control de versiones Git en un entorno de desarrollo profesional, mostrando paneles de cambios locales y commits.

Git se ha convertido en una herramienta casi imprescindible para quien desarrolla software, pero también para cualquier persona que necesite ordenar versiones de archivos y trabajar en equipo sin pisarse. Es un sistema de control de versiones distribuido: cada persona tiene una copia completa del proyecto y de su historial en su ordenador, así que puede consultar, comparar, experimentar y confirmar cambios sin depender de una conexión permanente al servidor. Eso sí, cuando llega el momento de compartir, aparecen los repositorios remotos, los permisos, las claves y las revisiones.

Esta guía está pensada para que puedas hacer una autoevaluación realista de tus conocimientos. No se trata de memorizar una lista enorme de comandos, sino de comprobar si sabes qué hace Git por dentro, cómo se organiza un repositorio, qué diferencias hay entre una rama, una etiqueta y un remoto, y cómo reaccionar cuando algo se tuerce. Si dominas lo básico y entiendes el porqué de cada paso, los comandos menos habituales se consultan sin drama en la documentación.

Qué conviene saber antes de medir tu nivel

Git nació de la mano de Linus Torvalds en 2005 y hoy es el estándar de facto en el desarrollo colaborativo. Su función principal es registrar la evolución de los archivos, coordinar a varias personas sobre el mismo código y permitir volver atrás si un cambio no sale bien. A diferencia de otros sistemas que almacenan diferencias línea a línea, Git trabaja con instantáneas del proyecto en momentos concretos; si un archivo no cambia, reutiliza la referencia anterior. Esa forma de guardar la información explica muchas de sus ventajas y también algunas confusiones iniciales.

La integridad es otra seña de identidad: Git identifica objetos mediante cadenas SHA de cuarenta caracteres, de modo que un cambio mínimo altera el identificador. La mayoría de operaciones son locales, y casi todo lo que haces añade información en lugar de borrarla, salvo que ejecutes acciones destructivas de forma consciente. Para entender su funcionamiento conviene distinguir tres zonas: el directorio de trabajo, donde editas; el área de preparación o staging, donde seleccionas lo que irá al siguiente commit; y el directorio Git, donde queda guardado el historial. También conviene conocer los objetos básicos: blobs para contenido de archivos, trees para directorios y estructuras, commits para instantáneas con autor, mensaje y padre, y tags para marcar puntos relevantes.

Git encaja de forma natural en procesos de integración continua y despliegue continuo. La integración continua automatiza compilaciones y pruebas cada vez que se integra código, mientras que el despliegue continuo lleva una versión validada a un entorno de prueba o producción. Herramientas como Jenkins, Travis CI, CircleCI, Docker o Kubernetes se apoyan en el historial y los eventos del repositorio para detectar fallos cuanto antes y publicar con más seguridad. Si vas a autoevaluarte, deberías poder explicar qué papel juega Git en ese flujo sin limitarte a decir que sirve para subir código.

Instalación y configuración inicial sin dolores de cabeza

Primer plano de un desarrollador escribiendo código en un ordenador portátil en un entorno de trabajo moderno.

La instalación depende del sistema. En Linux se suele usar el gestor de paquetes de la distribución, por ejemplo con sudo apt-get install git en Debian o Ubuntu; en macOS es habitual recurrir a Homebrew con brew install git; y en Windows lo normal es descargar el instalador de Git for Windows y seguir sus pantallas. En el instalador de Windows conviene prestar atención a detalles como la carpeta de destino, la creación de acceso directo, la integración de Git Bash en el menú contextual, la búsqueda diaria de actualizaciones, el editor de consola, el nombre de la rama inicial, la forma de añadir Git al PATH, el cliente SSH, la biblioteca SSL, el tratamiento de saltos de línea, la consola predeterminada, el comportamiento de git pull y el ayudante de credenciales. Elegir opciones coherentes desde el principio evita sorpresas raras después.

Para una experiencia cómoda, muchas personas eligen Nano o Vim como editor de consola, dejan que Git utilice su OpenSSH incluido, seleccionan la biblioteca nativa de Windows para SSL y optan por no modificar los saltos de línea al hacer checkout ni al confirmar. También suele venir bien usar la consola nativa del sistema y dejar el comportamiento de git pull en modo fast-forward o merge. Si trabajas con lector de pantalla, merece la pena configurar la consola para copiar y pegar con combinaciones cómodas, revisar la salida con los cursores de revisión y familiarizarte con el historial de comandos, el autocompletado con tabulador, la interrupción con Ctrl+C y la búsqueda en el historial con Ctrl+R.

Después de instalar, configura tu identidad para que cada confirmación quede bien etiquetada. Los comandos habituales son git config --global user.name "Nombre Apellidos" y git config --global user.email "[email protected]"; luego puedes comprobar el resultado con git config --list. Si vas a usar repositorios remotos, conviene generar claves. Para SSH puedes ejecutar ssh-keygen -t ed25519 -C "[email protected]" y decidir si proteges la clave privada con una contraseña. Para firmar commits y etiquetas con GPG puedes usar gpg --full-generate-key, elegir el tipo de clave, la caducidad y tus datos, y después localizar el identificador con gpg --list-secret-keys --keyid-format=long. Con ese identificador, Git aprende a firmar mediante git config --global user.signingkey ID, git config --global commit.gpgsign true y, si quieres firmar etiquetas por defecto, git config --global tag.gpgSign true.

La actualización también forma parte del mantenimiento. En Windows puedes ejecutar git update-git-for-windows y aceptar las indicaciones; en otros sistemas, actualiza desde el gestor de paquetes o el método que hayas usado. Si clonas por HTTPS y no quieres escribir credenciales todo el tiempo, existen ayudantes como credential.helper store o cache, aunque su comodidad tiene contrapartidas de seguridad. La opción más recomendable suele ser SSH con una clave bien protegida, combinada con tokens cuando la plataforma los exija.

  Cómo descargar videos de YouTube automáticamente con yt-dlp

Repositorios, objetos y estados: la base que se evalúa

Un repositorio es la carpeta especial donde Git guarda el proyecto y todo su historial. Puedes crearlo desde cero con mkdir proyecto, cd proyecto y git init; dentro aparecerá una carpeta .git que no debes tocar ni borrar, porque contiene la base de datos y la configuración. Si el proyecto ya existe en un servidor, lo habitual es clonarlo con git clone URL, lo que descarga una copia completa y establece un remoto llamado normalmente origin. Para conectar un repositorio local con uno remoto puedes usar git remote add origin URL, y para revisar los remotos disponibles, git remote o git remote -v.

El comando git status es tu brújula: muestra archivos modificados, añadidos, eliminados y no rastreados. Cuando ya sabes qué quieres incluir, usas git add archivo, git add . o git add --all para preparar cambios; después confirmas con git commit -m "mensaje claro". La variante git commit -am "mensaje" añade y confirma archivos ya rastreados, pero no incorpora archivos nuevos. Para revisar el historial está git log, que se puede recorrer y abandonar con la tecla q; para inspeccionar un cambio concreto está git show, y git show HEAD resulta cómodo para ver el último commit. Un buen autodiagnóstico consiste en saber qué está en el directorio de trabajo, qué está preparado y qué ya forma parte del historial.

También conviene dominar herramientas de recuperación. git reset --hard devuelve los archivos rastreados al estado del commit que corresponda y descarta cambios locales; git clean -d -f -x elimina archivos y carpetas no rastreados, incluidos los ignorados. Ambas órdenes pueden borrar trabajo de verdad, así que no se lanzan por costumbre. Para evitar que ciertos archivos entren en el repositorio, se usa un archivo .gitignore con rutas y patrones como *.exe, *.dll, *.pyc, *.mo, *.pot, carpetas de compilación o configuraciones locales. Ignorar lo que no aporta al proyecto mantiene el historial limpio y evita sustos con binarios o secretos.

Si necesitas viajar a un punto anterior, git checkout ID deja el directorio de trabajo como estaba en ese commit, y git checkout nombre-rama o git checkout main te devuelve a una rama. Para marcar hitos estables existen las etiquetas: las ligeras apuntan a un commit, mientras que las anotadas y firmadas incluyen mensaje y pueden llevar firma GPG. Se crean con git tag -m "mensaje" nombre, se listan con git tag --list y se envían al remoto con git push --tags. Una etiqueta bien puesta ahorra tener que recordar identificadores larguísimos.

Ramas, fusiones, rebases y conflictos

Espacio de trabajo de un programador con un editor de código abierto en la pantalla sobre una mesa de madera.

Una rama es una línea de desarrollo independiente. Sirve para probar una idea, corregir un fallo o preparar una función sin ensuciar la rama principal. Se listan, crean o eliminan con git branch, se cambia de rama con git checkout nombre y se puede crear y cambiar en un solo paso con git checkout -b nombre. Cuando una rama ya no hace falta, git branch -d nombre la elimina si su trabajo está integrado. Tener ramas cortas y con un objetivo claro facilita las revisiones y reduce conflictos.

Para integrar cambios existen dos caminos muy habituales. git merge rama combina el historial de la rama indicada con la actual y puede generar un commit de fusión; git rebase base reubica tus commits sobre otra base para dejar un historial más lineal. Rebase puede ser muy útil para ordenar trabajo local, pero reescribe la historia, así que no conviene usarlo a la ligera sobre ramas compartidas. En cualquier caso, antes de fusionar o rebasar es buena idea revisar el estado, hacer pruebas y asegurarte de que entiendes qué commits se van a mover. El historial debe contar una historia comprensible, no ser un cajón desastre.

Los conflictos aparecen cuando Git no puede integrar automáticamente cambios incompatibles, por ejemplo si dos personas tocan las mismas líneas de un archivo. git status identifica los archivos afectados y, dentro del texto, pueden aparecer marcas como <<<<<<< HEAD, ======= y >>>>>>> rama. Ahí toca comparar las versiones, conservar el contenido correcto, eliminar los marcadores, comprobar el resultado y preparar el archivo con git add antes de completar el commit de fusión. Si estabas haciendo un rebase, el paso siguiente suele ser git rebase --continue; si estabas haciendo un merge, confirmas con un commit. No conviene confirmar a ciegas un archivo que todavía tiene marcas de conflicto.

  Cómo pausar y controlar colas en Laravel paso a paso

Cuando un push es rechazado porque el remoto tiene novedades, la respuesta sana es traer y revisar esos cambios, integrarlos y resolver lo que haga falta antes de volver a enviar. Forzar el envío o descartar el trabajo propio para salir del paso puede provocar males mayores. Si no tienes claro cómo continuar, pide ayuda y conserva una copia de seguridad. Git premia la prudencia y castiga las prisas.

Colaboración remota y GitHub de punta a punta

Los remotos son los lugares a los que envías cambios con git push y de los que traes novedades con git pull. Un repositorio puede tener varios remotos o ninguno. Además de git remote y git remote -v, existen subcomandos como git remote add nombre URL, git remote remove nombre, git remote rename viejo nuevo y git remote update. La primera vez que publicas una rama suele usarse git push -u origin rama para dejar configurada la relación entre local y remoto. Antes de enviar, revisa qué commits van a salir y asegúrate de que no incluyes basura.

GitHub es la plataforma colaborativa más conocida alrededor de Git, aunque también existen GitLab y Bitbucket. Cada usuario u organización tiene una dirección propia, y los repositorios se visitan con patrones como https://github.com/usuario/repositorio. El archivo README.md se muestra en la portada y suele estar escrito en Markdown. Para descargar código sin intención de colaborar se puede bajar un ZIP, pero clonar con git clone conserva el historial y permite trabajar de verdad. Clonar no es lo mismo que copiar archivos sueltos.

Si quieres colaborar en un proyecto ajeno, lo habitual es buscar primero si ya existe una pull request o incidencia relacionada, bifurcar el repositorio con Fork, clonarlo en tu equipo, crear una rama temática, hacer cambios acotados, confirmarlos y enviarlos con git push -u origin rama. Después se abre una pull request desde la web, se explica qué se ha cambiado y por qué, y se participa en la conversación hasta que la acepten, la fusionen o la cierren. Mantener actualizado tu fork implica añadir el repositorio original como remoto, por ejemplo git remote add upstream URL, traer cambios con git pull upstream main o la rama equivalente, y subirlos a tu copia. Una pull request pequeña y bien explicada se revisa mucho mejor que un batiburrillo enorme.

Las incidencias, o issues, sirven para informar de fallos, sugerir mejoras o comentar decisiones. Antes de abrir una, conviene buscar si ya existe algo parecido. Dentro de una incidencia se pueden dejar comentarios, mencionar a otras personas con la arroba, adjuntar archivos pequeños y cerrarla desde la web o mediante un commit con textos como Fixes #5. GitHub también permite gestionar claves SSH y GPG, activar verificación en dos pasos, completar el perfil con nombre, biografía, empresa, ubicación, web, redes, correo público, foto, contribuciones privadas, disponibilidad para trabajar e idioma preferido. Una cuenta cuidada transmite confianza y facilita la colaboración.

Para comprobar la conexión SSH puedes ejecutar ssh -T [email protected] y aceptar la huella la primera vez. La clave pública se pega en GitHub, y la clave GPG se exporta con gpg --armor --export ID > clave.gpg para añadirla en la configuración de seguridad. Si el proyecto depende de otros repositorios, los submódulos permiten mantenerlos dentro de una carpeta; se inicializan con git submodule init y se descargan con git submodule update, y a veces conviene ejecutar antes git submodule sync. La lista de submódulos suele estar en .gitmodules. Los submódulos son útiles, pero exigen recordar que no se actualizan solos.

Las liberaciones o releases se apoyan en etiquetas. Se crea una etiqueta sobre el commit elegido, se envía con git push --tags, se entra en la página de releases y se pulsa la opción de crear una release desde esa etiqueta. Ahí se indica título, descripción, archivos binarios que quieras adjuntar y si se trata de una pre-release. GitHub también ofrece descargas automáticas del código fuente en ZIP o tar.gz. Publicar una release ordenada ayuda a que otras personas sepan qué están instalando.

CI/CD, buenas prácticas y política de ramas

Detalle de código de programación con sintaxis resaltada en modo oscuro sobre una pantalla de ordenador.

La integración continua y el despliegue continuo automatizan pruebas, compilaciones y publicaciones. Git actúa como fuente de verdad: cada push puede disparar una tubería que construye, prueba y despliega. Herramientas como Jenkins, Travis CI, CircleCI, Docker o Kubernetes encajan en ese ecosistema, pero no sustituyen el criterio humano. Una buena base de Git hace que la automatización sea fiable y que los errores se detecten antes de llegar a producción.

Entre las buenas prácticas están hacer commits frecuentes y pequeños, escribir mensajes descriptivos, revisar antes de confirmar, no mezclar cambios no relacionados y proteger las ramas importantes. También conviene no versionar secretos, binarios generados o configuraciones locales, y usar .gitignore para evitarlo. Si trabajas en equipo, documenta cómo se nombran las ramas y cómo se integran los cambios. La claridad ahorra tiempo a ti y a quien venga detrás.

  Dominando las Pruebas Unitarias de Software

Una política de ramas habitual distingue main, test y develop, además de ramas feature para cada desarrollo. Las feature permiten mantener develop estable; cuando el trabajo está probado en local, se abre una pull request, se recibe revisión y se integra. Develop sirve para comprobar que varias funcionalidades conviven; test se usa para pruebas específicas; main debe contener código estable y listo para producción, protegido para que no se fusione cualquier cosa sin revisión. No todas las ramas tienen el mismo nivel de exigencia.

Evaluar y certificar tus conocimientos

Si quieres medir tu nivel de forma más formal, existen certificaciones como GitHub Foundations, que validan conocimientos sobre Git, GitHub, colaboración, repositorios, desarrollo moderno, administración de proyectos, privacidad, seguridad y comunidad. El examen reparte su peso en áreas como introducción a Git y GitHub, trabajo con repositorios, funciones de colaboración, desarrollo moderno, gestión de proyectos, privacidad y seguridad, y beneficios de la comunidad. Preparar una certificación obliga a ordenar conceptos que a veces se usan sin entenderlos del todo.

El proceso de inscripción suele consistir en iniciar sesión con la cuenta personal, elegir el examen, seleccionar fecha y hora, pagar la tasa, confirmar los detalles y seguir las instrucciones el día de la prueba. El coste puede variar y a veces hay descuentos promocionales. Además de la certificación, herramientas como GitHub Copilot pueden ayudarte a centrarte en el código, pero no sustituyen saber qué hace un commit, una rama o una fusión. La tecnología cambia, pero los fundamentos bien aprendidos se reutilizan.

Preguntas útiles para detectar lagunas

Una autoevaluación seria debería incluir preguntas como estas: ¿sé explicar qué guarda un commit y en qué se diferencia de un tag?, ¿distingo entre área de preparación y directorio de trabajo?, ¿puedo resolver un conflicto sin dejar marcas?, ¿entiendo cuándo usar merge y cuándo rebase?, ¿sé cuándo un push rechazado exige revisar cambios remotos?, ¿tengo claro cómo se protege una rama principal y por qué se revisan pull requests? Si alguna respuesta se queda coja, no pasa nada: identificar la laguna ya es el primer paso para corregirla.

Con esta base puedes revisar tu dominio de Git de forma bastante completa: repositorios, objetos, estados, instalación, configuración, claves, commits, ramas, fusiones, rebases, conflictos, remotos, GitHub, incidencias, pull requests, etiquetas, releases, submódulos, CI/CD y buenas prácticas. La señal de un buen nivel no es saberlo todo de memoria, sino entender qué está pasando, saber dónde mirar y actuar sin sobrescribir el trabajo de los demás. Si además mantienes commits claros, pruebas antes de publicar y pides ayuda cuando hace falta, vas por muy buen camino.

Preguntas frecuentes

¿Cómo sé si tengo un conflicto de fusión en Git?

Git detiene la integración y el estado muestra los archivos afectados. Dentro del texto aparecen marcas de conflicto y debes elegir el contenido correcto, borrar esas marcas, preparar el archivo y confirmar la operación.

¿Qué hago si me rechazan un push porque el remoto tiene cambios?

Trae los cambios remotos, revísalos e intégralos en tu trabajo antes de volver a enviar. No fuerces el envío ni sobrescribas a ciegas lo que han hecho otras personas.

¿Cuál es la diferencia entre merge y rebase?

Merge combina historiales y puede crear un commit de unión. Rebase reubica tus commits sobre otra base para dejar un historial más lineal, pero reescribe la historia y conviene evitarlo en ramas compartidas.

¿Para qué sirven git reset y git clean?

Reset devuelve archivos al estado de un commit y puede descartar cambios locales. Clean elimina archivos no rastreados, incluidos los ignorados si se le indican las opciones adecuadas, así que revisa antes de ejecutarlos.

¿Cómo autentico Git con GitHub sin escribir la contraseña cada vez?

Genera un par de claves SSH, copia la pública en GitHub y prueba la conexión. También puedes usar un ayudante de credenciales o tokens, aunque SSH suele ser una opción cómoda y segura.

¿Qué es una pull request y cuándo debo abrirla?

Es una propuesta de cambios desde una rama o un fork para que otras personas la revisen. Conviene abrirla cuando el cambio está acotado, probado y bien explicado, no cuando mezcla cosas sin relación.

¿Cómo mantengo actualizado mi fork en GitHub?

Añade el repositorio original como remoto upstream, trae sus cambios a tu rama principal y súbelos después a tu fork. Así tus próximas pull requests partirán de una base más reciente.

¿Qué debe incluir un archivo gitignore?

Debe incluir rutas y patrones de archivos generados, binarios, configuraciones locales, secretos o cualquier cosa que no quieras versionar. Se aplica sobre todo a archivos que Git todavía no está rastreando.

TecnoDigital

TecnoDigital

Apasionado por la tecnología y el desarrollo de software, me adentro en el universo de sistemas e informática con el objetivo de fomentar la innovación y resolver desafíos complejos.