Home Git How to use Git commands to collaborate with others

How to use Git commands to collaborate with others

Effective teamwork in coding requires more than just skill; it demands mastery of tools like Git. Unlock collaborative success with this guide to essential Git commands for teams.

by Arun Kumar
git commands for collaboration

Welcome to the technical world of Git, which is the foundation of modern software development collaboration. As a developer, I have personally experienced the complexities and challenges of managing code across diverse teams. This guide aims to simplify Git’s core functionalities, providing you with a clear understanding of its commands, workflows, and best practices.

In this comprehensive overview, we will explore each essential Git command and provide real-world input and output examples to demonstrate their practical applications. From setting up and configuring your Git environment to advanced techniques such as branching, merging, and resolving conflicts, this guide covers the complete spectrum of Git operations that you will encounter in your daily development tasks.

Setting the stage with Git

What’s Git all about?

Git is not just a tool; it’s a game-changer for managing code versions and collaborating seamlessly. Its ability to track changes and branch out makes it indispensable in modern development.

Setting up: The first steps

After installing Git, setting up your identity is crucial. The git config command personalizes your Git environment. This identity is used in each commit.

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"



git config --global user.name "Jane Doe"
git config --global user.email "jane@example.com"


    name = Jane Doe
    email = jane@example.com

The core of collaboration: Git commands explained

Starting with git clone

The git clone command is your gateway to collaboration. It creates a local copy of a remote repository. This allows you to work on the project independently.

git clone https://github.com/username/repository.git



git clone https://github.com/team/project.git


Cloning into 'project'...
remote: Enumerating objects: 10, done.
remote: Counting objects: 100% (10/10), done.
remote: Compressing objects: 100% (8/8), done.
remote: Total 10 (delta 1), reused 10 (delta 1), pack-reused 0
Unpacking objects: 100% (10/10), done.

Branching out with git branch and git checkout

Branches are independent lines of development. The git branch command creates a new branch, and git checkout switches between branches.

git branch feature-branch
git checkout feature-branch

Or combine both:

git checkout -b feature-branch

This isolates your work from the main project (usually called the “main” branch).



git checkout -b new-feature


Switched to a new branch 'new-feature'

Staging and committing with git add and git commit

git add stages your changes for commit. It tells Git which changes you want to include in the next snapshot (commit).

git add .

Then, git commit snapshots your staged changes. The commit message should describe what you’ve done.

git commit -m "Add new feature"



git add feature.txt
git commit -m "Add new feature"


[new-feature 4c2efb6] Add new feature
 1 file changed, 10 insertions(+)

Sharing work with git push

To make your local changes available to others, use git push. This updates the remote repository with your branch.

git push origin feature-branch


To share your branch with the team:

git push origin new-feature


Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 4 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 452 bytes | 452.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/team/project.git
 * [new branch]      new-feature -> new-feature

Syncing with git pull

git pull updates your local branch with changes from the remote repository. It’s essential to do this often to keep your work in sync.

git pull origin main


To update your local branch:

git pull origin main


From https://github.com/team/project
 * branch            main     -> FETCH_HEAD
Already up to date.

Combining work with git merge

Merge integrates changes from one branch into another, typically used to bring a feature branch into the main branch.

git checkout main
git merge feature-branch


Merging your feature into the main branch:

git checkout main
git merge new-feature


Updating 4c2efb6..d13f5a7
 feature.txt | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 feature.txt

Resolving conflicts: A necessary skill

Conflicts happen when changes clash. Git marks these in your files. You’ll need to manually resolve these and then commit the resolution.

If a conflict arises, Git notifies you, and you’ll see something like this in the conflicted file:

<<<<<<< HEAD
Existing work
New conflicting work
>>>>>>> new-feature

You resolve it manually and then commit the resolved file.

Tracking changes with git status and git log

git status provides the status of your working directory and staging area. It’s useful to see what’s changed.

git status


On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean

git log shows the commit history, letting you track progress and changes over time.

git log


commit d13f5a7ec4e3b7f2c036e5c3fc5c850a4f60b2e1 (HEAD -> main, origin/main)
Author: Jane Doe <jane@example.com>
Date: Thu Sep 10 12:56:19 2023 -0400

Merge branch 'new-feature'

commit 4c2efb63fe2795ef72b7af6c8e4e0a35d7b4f9fa (origin/new-feature, new-feature)
Author: Jane Doe <jane@example.com>
Date: Thu Sep 10 12:54:03 2023 -0400

Add new feature

Beyond the basics: Advanced commands

Saving work temporarily with git stash

Use git stash to temporarily shelve changes without committing them, allowing you to switch contexts quickly.

git stash

Retrieve them with git stash pop.


Saved working directory and index state WIP on main: d13f5a7 Merge branch 'new-feature'

Streamlining history with git rebase

Rebasing rewrites history by changing the base of your branch. It’s a cleaner alternative to merging.

git rebase main


First, rewinding head to replay your work on top of it...
Applying: Add new feature

Pull requests: Collaborating on code platforms

The pull request process

Pull requests (PRs) are essential for reviewing code in a shared repository. They initiate discussions about your proposed changes before merging them.

Merging PRs

After a team review, PRs are merged, integrating your changes into the main branch.

Git best practices: Tips and tricks

  • Commit small, commit often.
  • Use clear, descriptive commit messages.
  • Regularly sync with the main branch.
  • Review and discuss code changes through PRs.

Quick reference table: Essential Git commands and their uses

Here’s a handy table that succinctly summarizes key Git commands and their primary uses. It’s a quick-reference guide to help you recall the purpose of each command in real-time scenarios.

Git Command Primary Use
git clone [url] Clones a remote repository to your local machine, setting up a workspace to start contributing.
git config --global user.name

git config --global user.email

Sets up your Git identity for commits.
git branch [branch-name] Creates a new branch, allowing for parallel development streams.
git checkout [branch-name] Switches to the specified branch to work on different parts of the project.
git checkout -b [branch-name] Creates a new branch and immediately switches to it, streamlining branch creation and checkout.
git add [file] Stages a file, preparing it for inclusion in the next commit.
git commit -m "[message]" Records your changes to the repository, effectively saving your work with a descriptive message.
git push origin [branch-name] Uploads your branch to the remote repository, sharing your work with the team.
git pull origin [branch-name] Updates your local branch with changes from the remote repository.
git merge [branch-name] Integrates changes from one branch into another, typically used for merging features into main.
git status Shows the status of changes as untracked, modified, or staged.
git log Displays the commit history of the repository, helping track changes and contributions.
git stash Temporarily shelves changes you’ve made to your working directory so you can work on something else.
git rebase [branch-name] Transfers completed work from one branch to another, often used for keeping a clean project history.

Frequently Asked Questions (FAQs) about using Git

Q1: What is Git and why is it important for collaboration?

A1: Git is a version control system that helps manage and track changes in software development projects. It’s crucial for collaboration because it allows multiple developers to work on the same project simultaneously without overwriting each other’s changes.

Q2: How do I start using Git in my project?

A2: To start using Git, first install it on your machine. Then, set up your user information with git config, and clone a repository with git clone to get a local copy of the project to work on.

Q3: What is the difference between git pull and git fetch?

A3: git pull updates your current branch with the latest changes from the remote repository, automatically merging them. git fetch downloads the latest data from the remote repository without automatically merging the changes into your current branch.

Q4: How do I resolve merge conflicts in Git?

A4: Merge conflicts occur when Git can’t automatically reconcile differences in code between two commits. To resolve them, manually edit the conflicted files to select the changes you want to keep, then stage and commit the resolved files.

Q5: What is a ‘branch’ in Git, and how do I use it?

A5: A branch in Git represents an independent line of development. Use branches to work on new features or bug fixes without affecting the main codebase. Create a branch with git branch, switch to it with git checkout, and merge it back into the main branch when the work is complete.

Q6: Is it necessary to use command line for Git? Are there GUI alternatives?

A6: While the command line is a powerful way to use Git, there are also several GUI (Graphical User Interface) tools available, like GitHub Desktop, Sourcetree, or GitKraken, which make it easier to visualize and manage repositories.

Q7: How often should I commit changes in Git?

A7: It’s good practice to commit changes frequently. Each commit should represent a logical unit of work. This approach makes it easier to understand the project history and isolate issues if they arise.

Q8: What are ‘pull requests’ in Git, and how do they work?

A8: Pull requests are a feature of online repository hosting services like GitHub. They let you notify team members about changes you’ve pushed to a branch in a repository. Pull requests are a way to discuss and review your changes before they are merged into the main branch.

Q9: How can I view the history of my Git repository?

A9: Use the git log command to view the commit history of your repository. It shows a list of commits with their respective details like author, date, and commit message.

Q10: Can I undo a commit in Git?

A10: Yes, you can undo a commit in Git. The git revert command creates a new commit that undoes the changes made in a specified commit. Alternatively, git reset can be used to reset your branch to a previous commit state, but use it cautiously as it can alter the project history.


As we come to the end of this guide, it is evident that Git is much more than just a version control system. It’s an indispensable tool for efficient and collaborative software development. By comprehending and mastering the commands and practices we’ve covered, you can significantly enhance your team’s ability to manage complex projects with ease and precision.

Every aspect of Git, from setting up your Git environment to navigating advanced features like branching and merging, plays a crucial role in facilitating a seamless workflow. The real-world examples provided aim to bridge the gap between theory and practice, giving you a practical framework to apply these commands in your daily work.

You may also like

Leave a Comment



FOSS Linux is a leading resource for Linux enthusiasts and professionals alike. With a focus on providing the best Linux tutorials, open-source apps, news, and reviews written by team of expert authors. FOSS Linux is the go-to source for all things Linux.

Whether you’re a beginner or an experienced user, FOSS Linux has something for everyone.

Follow Us


©2016-2023 FOSS LINUX



“Linux” is the registered trademark by Linus Torvalds in the U.S. and other countries.