Question 1

What is Git Push Studio?

Accepted Answer

Git Push Studio is a free online Git command reference designed for developers at every skill level. It covers 28 commands across 8 categories — from git init to git rebase — with clear, practical explanations and real-world examples that you can copy and run directly in your terminal. Each command entry includes a description, detailed explanation of how it works under the hood, common flags and options, and a working example. The entire reference is searchable with Ctrl+K or Cmd+K, so you can find the right command instantly.

Question 2

Who is this for?

Accepted Answer

Anyone learning Git — from absolute beginners writing their first commit to experienced developers who need a quick syntax reference on hand. If you are new to version control, start with the Getting Started category. If you already know the basics, use the search bar to jump directly to specific commands like git rebase, git stash, or git reflog. The reference is also useful for teachers conducting Git workshops and teams standardizing their Git workflows.

Question 3

Do I need to install anything?

Accepted Answer

No — everything on this site is available online and ready to read. To actually run the commands on your own machine, you will need Git installed. Download it for free from git-scm.com, which provides installers for macOS, Windows, and Linux. Once installed, open your terminal and start practicing. Every example on this site is designed to be copied and pasted directly into your terminal. We recommend following along with each example to build muscle memory.

Question 4

What is Git?

Accepted Answer

Git is a distributed version control system created by Linus Torvalds in 2005. It tracks changes in your code over time, lets you save snapshots called commits, create isolated branches for experimental work, and collaborate with other developers without overwriting each other's changes. Unlike older centralized systems (like SVN), every developer has a full copy of the entire repository history on their local machine. This means you can work offline, commit locally, and only sync with others when you are ready. Git powers GitHub, GitLab, Bitbucket, and nearly every open source project on the planet.

Question 5

What is a repository?

Accepted Answer

A repository (or repo) is simply a folder that Git is tracking. It contains all your project files plus a hidden .git subdirectory where Git stores the complete history of every change ever made — every commit, branch, tag, and configuration setting. When you run git init, this .git folder is created. When you clone a repository from GitHub, the entire .git history comes with it. Repositories can be local (on your machine) or remote (hosted on GitHub, GitLab, etc.). Changes flow between local and remote repositories via git push and git pull.

Question 6

What is a commit?

Accepted Answer

A commit is a snapshot of your entire project at a specific point in time. Each commit includes a unique 40-character SHA-1 hash (like abc1234def5678...), the author name and email, a timestamp, a commit message describing what changed and why, and a pointer to its parent commit — which forms the chain of history. When you run git commit, Git takes everything currently in the staging area and creates this permanent record. Commits are immutable: once created, their content should not be changed, especially if they have been shared with others. This immutability is what makes Git history trustworthy.

Question 7

What is the difference between git add and git commit?

Accepted Answer

Git uses a two-step process for recording changes. First, git add moves changes from your working directory into the staging area (also called the index). This is where you select which modified files will be part of the next snapshot. Then, git commit takes everything in the staging area and creates a permanent snapshot in the repository history. Think of git add like selecting items to put in a package, and git commit like sealing and shipping the package. This two-step process gives you fine-grained control — you can make multiple changes to a file but only commit some of them using git add -p (interactive staging).

Question 8

How do I undo a commit?

Accepted Answer

It depends on whether the commit has been pushed to a shared branch. For commits that are only on your local machine, use git reset: git reset --soft HEAD~1 keeps changes staged, git reset --mixed HEAD~1 keeps changes in your working directory (unstaged), and git reset --hard HEAD~1 discards them entirely. For commits already pushed to a shared branch like main, never use reset — use git revert instead, which creates a new commit that reverses the target commit's changes. Revert is safe because it does not rewrite history. You can also use git commit --amend to modify the most recent commit (message or content) if it has not been pushed.

Question 9

What does git status show?

Accepted Answer

git status shows the current state of your working directory and staging area. It displays exactly which files are modified but not staged, which files are staged and ready to commit, and which files are untracked (new files Git does not know about). It also shows the current branch name and whether it is ahead of or behind its remote counterpart. Run git status constantly — it is the safest command in Git and tells you exactly what is happening in your repository at any moment. For a more concise version, use git status -s (short format), which displays a compact two-column output.

Question 10

What is a branch?

Accepted Answer

A branch is a lightweight, movable pointer to a specific commit. When you create a branch, Git simply creates a new pointer at your current commit — it does not copy any files. This makes branching incredibly fast and cheap. Branches let you develop features, fix bugs, or experiment in complete isolation from the main codebase. The default branch is usually called main (or master in older repositories). You can create as many branches as you want, merge them back when ready, and delete them when done. Modern Git workflow encourages creating a branch for every feature or bug fix, no matter how small.

Question 11

What is the difference between merge and rebase?

Accepted Answer

Both integrate changes from one branch into another, but they produce different history. Merge creates a new merge commit that has two parents, preserving the exact timeline of when branches diverged and were reunited. This is accurate but can clutter history with merge bubbles. Rebase rewrites your commits by replaying them on top of another branch, producing a perfectly linear history as if all work was done sequentially. The trade-off: merge preserves context but adds noise, rebase keeps history clean but rewrites commit hashes. Use merge for shared branches and long-running feature branches. Use rebase for personal branches and when preparing a pull request.

Question 12

How do I resolve a merge conflict?

Accepted Answer

When Git cannot automatically merge changes because two branches modified the same part of a file, it marks the conflicting files with conflict markers (<<<<<<<, =======, and >>>>>>>) that show both versions side by side. To resolve: open each conflicted file, find the markers, decide which version to keep (or edit to combine both), remove the markers and the unwanted code, save the file, then stage it with git add. After resolving all conflicts, run git commit to finalize the merge. Use git status during this process to see which files still have conflicts. Use git merge --abort to cancel the merge and return to the pre-merge state if you get stuck.

Question 13

What is a remote repository?

Accepted Answer

A remote is a copy of your repository hosted on a server — typically GitHub, GitLab, or Bitbucket. Remotes allow you to back up your work, share it with others, and collaborate without sending files back and forth. When you clone a repository, Git automatically creates a remote called 'origin' pointing to the original URL. You can add multiple remotes — for example, origin pointing to your fork and upstream pointing to the original repository. Use git remote -v to list all remotes with their URLs. Communication with remotes happens through git push (upload), git fetch (download without merging), and git pull (download and merge).

Question 14

What is the difference between git fetch and git pull?

Accepted Answer

git fetch downloads commits, files, and references from a remote repository but does not change your working directory or current branch. This makes it a safe, read-only operation — you can inspect what changed before deciding how to integrate it. After fetching, review the changes with git log origin/main or compare with git diff main origin/main. git pull, on the other hand, is a convenience command that runs git fetch followed immediately by git merge (or git rebase if configured). It updates your current branch in one step. For maximum control, use fetch first, then decide whether to merge or rebase. For convenience when you are sure about incoming changes, use pull.

Question 15

What does git push do?

Accepted Answer

git push uploads your local commits to a remote repository, making them visible to collaborators and updating the remote branch to match yours. You need write access to the remote to push. If the remote has commits you do not have locally, Git rejects the push — you must git pull first to incorporate those changes. The -u flag sets the upstream tracking relationship so you can use just git push afterwards without specifying the remote and branch. Use git push --dry-run to preview what would be pushed. For deleting remote branches, use git push origin --delete branch-name. Never force-push (--force) to shared branches — it overwrites remote history and disrupts collaborators.

Question 16

How do I fix a messed up commit message?

Accepted Answer

If the commit has not been pushed yet, use git commit --amend to edit the most recent commit message. This opens your configured editor with the current message — edit and save. For a quick inline fix, use git commit --amend -m "New message". If the commit has already been pushed, amending creates a new commit hash, which means you will need to force-push to update the remote branch. Use git push --force-with-lease (safer than --force) after amending a pushed commit. For older commits that need message fixes, use git rebase -i, mark the target commit with 'reword', and update the message. Be careful — any history rewrite on shared branches requires coordination with your team.

Question 17

I accidentally committed to the wrong branch. What do I do?

Accepted Answer

This is a common mistake with a straightforward fix. First, find the commit hash with git log. Then switch to the correct branch with git checkout correct-branch. Apply the commit there using git cherry-pick . Finally, go back to the original branch and remove the accidental commit with git reset --hard HEAD~1 (if it is the most recent commit) or git reset --hard . If the commit has already been pushed, you will need to force-push after resetting, and the cherry-picked commit on the correct branch can be pushed normally. Cherry-pick is a safe way to copy specific commits between branches without merging the entire branch.

Question 18

How do I recover a deleted branch?

Accepted Answer

Use git reflog to find the commit hash that was at the tip of the deleted branch before it was deleted. The reflog records every movement of HEAD — including branch deletions. Look for the commit that was on the deleted branch, then recreate it with git branch recovered-branch <hash>. Once the branch is recreated, its history is fully intact including all commits that were in it. This works because Git retains unreferenced commits for 30-90 days before garbage collection removes them. The reflog is local to your machine, so if the branch was never pushed, it can only be recovered on the machine where it was deleted. If it was pushed, simply fetch from the remote to recover it.

Support

About the Reference

Git Basics

Commands & Usage

Branching & Merging

Working with Remotes

Troubleshooting