Git Self-Assessment Guide: Repositories, Branches, and Collaboration

Last update: November 21th 2026
  • Understanding that Git saves complete snapshots and allows working locally with a complete history.
  • Knowing how to move changes between working directory, staging area and repository using basic commands.
  • Resolve branches, merges, and conflicts without overwriting other people's work or losing your own changes.
  • Collaborate on GitHub with remotes, issues, pull requests, reviews, tags, and releases.

Programmer using a Git version control tool in a professional development environment, showing local change and commit panels.

Git has become an almost indispensable tool for software developers, but also for anyone who needs to organize file versions and work as a team without overwriting each other's work. It's a distributed version control system : each person has a complete copy of the project and its history on their computer, so they can consult, compare, experiment, and commit changes without depending on a constant connection to the server. However, when it comes to sharing, remote repositories, permissions, keys, and revisions come into play.

This guide is designed to help you realistically assess your knowledge . It's not about memorizing a huge list of commands, but about checking if you understand how Git works internally, how a repository is organized, the differences between a branch, a tag, and a remote, and how to react when something goes wrong. If you master the basics and understand the reasoning behind each step, you can easily find less common commands in the documentation.

What you should know before measuring your level

Git was created by Linus Torvalds in 2005 and is now the de facto standard for collaborative development. Its main function is to record the evolution of files , coordinate multiple people working on the same code, and allow users to revert changes if they don't work. Unlike other systems that store differences line by line, Git works with snapshots of the project at specific points in time; if a file doesn't change, it reuses the previous reference. This way of storing information explains many of its advantages and also some of the initial confusion.

Integrity is another defining characteristic: Git identifies objects using forty-character SHA strings, so even a minor change alters the identifier. Most operations are local , and almost everything you do adds information rather than deleting it, unless you intentionally perform destructive actions. To understand how it works, it's helpful to distinguish three areas: the working directory, where you edit; the staging area, where you select what will go in the next commit; and the Git directory, where the history is stored. It's also useful to know the basic objects: blobs for file contents, trees for directories and structures, commits for snapshots with author, message, and parent, and tags for marking relevant points.

Git fits naturally into continuous integration and continuous deployment processes. Continuous integration automates builds and tests every time code is integrated, while continuous deployment brings a validated version to a test or production environment. Tools like Jenkins, Travis CI, CircleCI, Docker, and Kubernetes rely on repository history and events to detect errors earlier and deploy more securely . If you're going to self-assess, you should be able to explain Git's role in this workflow without simply saying it's used to upload code.

Hassle-free installation and initial setup

Close-up of a developer writing code on a laptop in a modern work environment.

Installation depends on the system. On Linux, the distribution's package manager is usually used, for example with sudo apt-get install git On Debian or Ubuntu; on macOS it is common to use Homebrew with brew install gitOn Windows, the usual procedure is to download the Git for Windows installer and follow the on-screen instructions. In the Windows installer, it's worth paying attention to details such as the destination folder, shortcut creation, Git Bash integration into the context menu, daily update checks, the console editor, the initial branch name, how to add Git to the PATH, the SSH client, the SSL library, line break handling, the default console, and the behavior of... git pull and the credentials assistant. Choose consistent options from the start avoid strange surprises later.

For a comfortable experience, many people choose Nano or Vim as their console editor, let Git use its built-in OpenSSH, select the native Windows library for SSL, and choose not to modify line breaks during checkout and commit. It's also often best to use the system's native console and leave the behavior of git pull in fast-forward or merge mode. If you work with a screen reader, it's worth configuring the console for convenient copy and paste shortcuts, reviewing output with the review cursors, and familiarizing yourself with command history, tab autocomplete, Ctrl+C interrupt, and Ctrl+R history search.

After installation, configure your identity so that each confirmation is properly labeled. Common commands are: git config --global user.name "Nombre Apellidos" y git config --global user.email "[email protected]"Then you can check the result with git config --listIf you're going to use remote repositories, it's advisable to generate keys. For SSH, you can run ssh-keygen -t ed25519 -C "[email protected]" and decide whether to protect the private key with a password. To sign commits and tags with GPG you can use gpg --full-generate-keyChoose the key type, expiration date, and your details, and then locate the identifier with gpg --list-secret-keys --keyid-format=longWith that identifier, Git learns to sign using git config --global user.signingkey ID, git config --global commit.gpgsign true And, if you want to sign labels by default, git config --global tag.gpgSign true.

The update is also part of maintenance. On Windows you can run git update-git-for-windows and accept the prompts; on other systems, update from the package manager or the method you used. If you're cloning over HTTPS and don't want to enter credentials every time, there are helpers like credential.helper store o cacheHowever, its convenience comes at a cost in terms of safety. The most recommended option is usually SSH with a well-protected key., combined with tokens when the platform requires them.

  Deciphering Neural Networks: From Classical Architecture to the Weightless Revolution

Repositories, objects, and states: the basis that is evaluated

A repository is the special folder where Git stores the project and its entire history. You can create one from scratch with mkdir proyecto, cd proyecto y git init; a folder will appear inside .git which you shouldn't touch or delete, because it contains the database and configuration. If the project already exists on a server, the usual practice is to clone it with git clone URLwhich downloads a full copy and establishes a remote, normally called originTo connect a local repository to a remote one, you can use git remote add origin URLand to check the available remotes, git remote o git remote -v.

The command git status It's your compass: it shows modified, added, deleted, and untracked files. Once you know what you want to include, you use git add archivo, git add . o git add --all to prepare changes; then confirm with git commit -m "mensaje claro". Variant git commit -am "mensaje" It adds and confirms previously scanned files, but does not add new files. To review the history, go to git logwhich can be navigated and exited with the q key; to inspect a specific change there is git show, and git show HEAD It's convenient for viewing the latest commit. A good self-diagnosis consists of knowing what is in the working directory, what is prepared, and what is already part of the history.

It is also advisable to master recovery tools. git reset --hard returns the tracked files to the corresponding commit state and discards local changes; git clean -d -f -x It removes untracked files and folders, including ignored ones. Both commands can actually delete work, so they aren't run out of habit. To prevent certain files from entering the repository, a file is used. .gitignore with routes and patterns like *.exe, *.dll, *.pyc, *.mo, *.pot, build folders or local configurations. Ignore what does not contribute to the project It keeps the history clean and avoids surprises with binaries or secrets.

If you need to travel to a previous point, git checkout ID Leave the working directory as it was in that commit, and git checkout nombre-rama o git checkout main It returns you to a branch. To mark stable milestones, there are tags: lightweight tags point to a commit, while annotated and signed tags include a message and can carry a GPG signature. They are created with git tag -m "mensaje" nombre, are listed with git tag --list and are sent to the remote with git push --tags. A well-placed label saves you from having to remember very long identifiers.

Branches, mergers, rebases, and conflicts

A programmer's workspace with an open-source code editor on the screen on a wooden table.

A branch is an independent line of development. It's used to test an idea, fix a bug, or prepare a feature without affecting the main branch. Branches are listed, created, or deleted with git branch, you switch branches with git checkout nombre and can be created and changed in a single step with git checkout -b nombreWhen a branch is no longer needed, git branch -d nombre It eliminates it if your job is integrated. Have short branches with a clear objective It facilitates reviews and reduces conflicts.

There are two very common ways to integrate changes. git merge rama combines the history of the specified branch with the current one and can generate a merge commit; git rebase base Rebase your commits to a different base to create a more linear history. Rebasing can be very useful for organizing local work, but it rewrites the history, so it's not advisable to use it lightly on shared branches. In any case, before merging or rebasing, it's a good idea to review the state, run tests, and make sure you understand which commits are being moved. The record should tell a comprehensible story, not be a hodgepodge.

Conflicts arise when Git cannot automatically integrate incompatible changes, for example if two people touch the same lines of a file. git status It identifies the affected files and, within the text, markers such as may appear <<<<<<< HEAD, ======= y >>>>>>> ramaThat's where you need to compare the versions, keep the correct content, remove the bookmarks, check the result, and prepare the file with git add before completing the merge commit. If you were doing a rebase, the next step is usually git rebase --continueIf you were doing a merge, you confirm with a commit. It is not advisable to blindly confirm a file that still has conflict markers.

  What is Python and why is it so popular?

When a push is rejected because the remote team has new features, the best course of action is to retrieve and review those changes, integrate them, and resolve any issues before resubmitting. Forcing a push or discarding your own work to get by can cause bigger problems. If you're unsure how to proceed, ask for help and keep a backup. Git rewards prudence and penalizes haste.

Remote collaboration and end-to-end GitHub

Remotes are the places to which you send changes with git push and those that you bring new things with git pullA repository can have multiple remotes or none. In addition to git remote y git remote -vThere are subcommands such as git remote add nombre URL, git remote remove nombre, git remote rename viejo nuevo y git remote updateThe first time you publish a branch, it is usually used git push -u origin rama to configure the relationship between local and remote. Before submitting, review which commits will be sent and make sure you don't include junk.

GitHub is the best-known collaborative platform for Git, although GitLab and Bitbucket also exist. Each user or organization has its own address, and repositories are accessed using patterns such as https://github.com/usuario/repositorio. The file README.md It's displayed on the homepage and is usually written in Markdown. To download code without intending to contribute, you can download a ZIP file, but cloning with git clone It preserves the history and allows you to actually work. Cloning is not the same as copying individual files.

If you want to collaborate on someone else's project, the usual procedure is to first check if a related pull request or issue already exists, fork the repository, clone it on your machine, create a thematic branch, make limited changes, commit them, and push them. git push -u origin ramaThen you open a pull request from the website, explain what has changed and why, and participate in the conversation until it's accepted, merged, or closed. Keeping your fork up to date involves adding the original repository as a remote, for example. git remote add upstream URLto bring about changes with git pull upstream main or the equivalent branch, and upload them to your copy. A small, well-explained pull request is reviewed much better than a huge jumble.

Issues are used to report problems, suggest improvements, or comment on decisions. Before opening one, it's a good idea to check if something similar already exists. Within an issue, you can leave comments, mention other people with the @ symbol, attach small files, and close it from the website or by committing with text such as Fixes #5GitHub also allows you to manage SSH and GPG keys, activate two-step verification, complete your profile with name, biography, company, location, website, networks, public email, photo, private contributions, availability to work, and preferred language. A well-maintained account conveys trust and facilitates collaboration.

To check the SSH connection you can run ssh -T [email protected] and accept the fingerprint the first time. The public key is pasted into GitHub, and the GPG key is exported with gpg --armor --export ID > clave.gpg to add it to the security settings. If the project depends on other repositories, submodules allow you to keep them within a folder; they are initialized with git submodule init and they are downloaded with git submodule updateand sometimes it's best to run it before git submodule syncThe list of submodules is usually found in .gitmodules. Submodules are useful, but they require remembering that they don't update themselves.

Releases rely on tags. A tag is created for the chosen commit and sent with git push --tagsGo to the releases page and click the option to create a release from that tag. There you specify the title, description, any binaries you want to include, and whether it's a pre-release. GitHub also offers automatic downloads of the source code in ZIP or tar.gz format. Publishing an organized release helps other people know what they are installing.

CI/CD, good practices and branch policy

Programming code detail with syntax highlighted in dark mode on a computer screen.

Continuous integration and continuous deployment automate testing, builds, and releases. Git acts as the source of truth: each push can trigger a pipeline that builds, tests, and deploys. Tools like Jenkins, Travis CI, CircleCI, Docker, and Kubernetes fit into this ecosystem, but they don't replace human judgment. A solid Git foundation makes automation reliable and ensures that bugs are caught before reaching production.

Good practices include making frequent, small commits, writing descriptive messages, reviewing before committing, not merging unrelated changes, and protecting important branches. It's also advisable not to version secrets, generated binaries, or local configurations, and to use .gitignore To avoid this, if you work in a team, document how branches are named and how changes are integrated. Clarity saves time for you and whoever comes after you.

  Claude Sonnet 4.5: Agents who program, use computers, and stay on track

A typical branching policy distinguishes main, test y developIn addition to feature branches for each development project, features allow for a stable develop environment. Once the work is tested locally, a pull request is opened, reviewed, and integrated. The develop branch is used to verify that various functionalities work together; the test branch is used for specific tests; and the main branch should contain stable, production-ready code, protected to prevent unchecked merging. Not all branches have the same level of demand.

Evaluate and certify your knowledge

If you want to formally assess your skills, there are certifications like GitHub Foundations, which validate knowledge of Git, GitHub, collaboration, repositories, modern development, project management, privacy, security, and community. The exam covers areas such as an introduction to Git and GitHub, working with repositories, collaboration features, modern development, project management, privacy and security, and community benefits. Preparing for a certification requires organizing concepts that are sometimes used without fully understanding them.

The registration process typically involves logging in with your personal account, choosing the exam, selecting a date and time, paying the fee, confirming the details, and following the instructions on the day of the test. The cost may vary, and promotional discounts are sometimes available. In addition to certification, tools like GitHub Copilot can help you focus on the code, but they don't replace understanding what a commit, a branch, or a merge does. Technology changes, but well-learned fundamentals are reusable.

Useful questions to detect gaps

A serious self-assessment should include questions like these: Can I explain what a commit stores and how it differs from a tag? Do I distinguish between a staging area and a working directory? Can I resolve a conflict without leaving any traces? Do I understand when to use merge and when to rebase? Do I know when a rejected push requires reviewing remote changes? Do I understand how to protect a main branch and why pull requests are reviewed? If any answer feels incomplete, that's okay: identifying the gap is the first step toward correcting it.

With this foundation, you can thoroughly review your Git domain: repositories, objects, state, installation, configuration, keys, commits, branches, merges, rebases, conflicts, remotes, GitHub, issues, pull requests, tags, releases, submodules, CI/CD, and best practices. A sign of a good level of expertise isn't knowing everything by heart , but rather understanding what's happening, knowing where to look, and acting without overwriting others' work. If you also maintain clear commits, test before publishing, and ask for help when needed, you're well on your way.

FAQ

How do I know if I have a merge conflict in Git?

Git stops the integration, and the status shows the affected files. Within the text, conflict markers appear; you must select the correct content, remove those markers, prepare the file, and commit the operation.

What do I do if a push request is rejected because the remote server has changed?

Bring in the remote changes, review them, and integrate them into your work before resubmitting. Don't force submissions or blindly overwrite what others have done.

What is the difference between merge and rebase?

Merge combines histories and can create a merge commit. Rebase rebases your commits onto another base to create a more linear history, but it rewrites the history and should be avoided on shared branches.

What are git reset and git clean used for?

Reset returns files to a committed state and can discard local changes. Clean removes untracked files, including ignored ones if given the appropriate options, so double-check before running it.

How do I authenticate Git with GitHub without entering the password each time?

Generate an SSH key pair, copy the public key to GitHub, and test the connection. You can also use a credential helper or tokens, although SSH is usually a convenient and secure option.

What is a pull request and when should I open one?

It's a proposed change from a branch or fork for others to review. It's best to open it when the change is well-defined, tested, and clearly explained, not when it mixes unrelated things.

How do I keep my fork updated on GitHub?

Add the original repository as an upstream remote, pull its changes to your main branch, and then push them to your fork. This way, your future pull requests will be based on a more recent version.

What should a gitignore file include?

This should include paths and patterns for generated files, binaries, local configurations, secrets, or anything else you don't want to version. It primarily applies to files that Git isn't yet tracking.

TecnoDigital

TecnoDigital

Passionate about technology and software development, I delve into the world of systems and computing with the aim of fostering innovation and solving complex challenges.