High-Frequency Git Operations for Everyday Development

Here are some of the most frequent Git operations you may need in day-to-day development.

Connect Your Local Folder to a GitHub Repository

Scenario

You have an existing local folder with files and want to connect it to an already existing GitHub repository.

Steps

Initialize Git in your folder:

git init

Add your GitHub repository (replace URL with your repo):

git remote add origin https://github.com/username/repo.git

Fetch remote history:

git fetch origin

Merge remote and local files, allowing unrelated histories (change main to your repo's default branch if necessary):

git pull origin main --allow-unrelated-histories

If you see an error like:

The following untracked working tree files would be overwritten by merge...

We recommend:

# 1. Move local conflicting files to a temporary directory
# For example, back them up to a non-conflicting `backup` folder in the current directory
mkdir backup
mv conflicting-file-1 conflicting-file-2 backup/

# 2. Try pulling the remote repository content again
git pull origin main --allow-unrelated-histories

# 3. Manually merge the backed up files into the pulled files

Commit after resolving all conflicts:

git add .
git commit -m "Merge local files with remote repository"

Push to the remote repository (if needed):

git push --set-upstream origin main

The --set-upstream origin main option is only needed for the first push; you don't need it afterward.

List What Files git add . Would Stage

git status --short

Example Output:

M file1.txt       # modified file
?? newfile.txt     # untracked file

Breakdown:

• M = Modified (but not staged)
• ?? = Untracked (new files)

Remove Previously Committed Files Now in .gitignore

Scenario

You added rules to .gitignore but some files were already committed.

Steps

Stage removal of all currently tracked files (but not delete locally):

git rm -r --cached .

Add everything back to the repo ("add" skips gitignored files):

git add .

Commit the change:

git commit -m "Remove ignored files from the repository"

At this point, the files are only removed from the repository from this commit onward (they'll still exist in older commits/history). If you want them removed from previous commits as well, consider squashing multiple commits into a single commit, as explained below.

List Files Added, Removed, or Changed Relative to Another Commit

Run git status and ensure you have no unstaged changes or staged but uncommitted changes. Then, to compare the current state (HEAD) against commit abcdef1:

git diff --name-status --no-renames abcdef1

Output looks like:

A  src/new_file.py
D  src/old_file.py
M  src/changed_file.py

• Added (A): File is present in HEAD but not in abcdef1.
• Deleted (D): File is present in abcdef1, but not in HEAD.
• Modified (M): File exists in both, but contents changed.

Squash Multiple Commits into a Single Commit

Scenario

You have made several small commits (some of which may be faulty or embarassing) and want to clean up history by squashing them into one.

Steps

Review commit history:

git log

Decide how many previous commits you want to squash.

Start an interactive rebase, e.g. with the last 3 commits:

git rebase -i HEAD~3

In the opened editor:

• Leave pick for the first commit.
• For the others, change pick to squash (or just s).
• Save and close.

You will then enter a second editor session. Edit the combined commit message. Save and close.

Force-push the branch to rewrite history on GitHub:

git push --force

Note

• Use squashing carefully if collaborating, as force push overwrites history.

List Branches

List local branches:

git branch

List remote branches:

git branch -r

List local and remote branches:

git branch -a

List Commits in Branches

To list commits in the branch feature:

git log feature

Copy Files and Folders from Another Branch or Commit Into Your Current Working Directory

Copy files and folders from the tip of branch feature into your current working directory:

git checkout feature -- path/to/file path/to/folder

Copy files and folders from commit abcdef1 into your current working directory:

git checkout abcdef1 -- path/to/file path/to/folder

Delete a Local Branch

git branch -d branch_name

• This will refuse if the branch contains undeleted/unmerged changes.

List Remotes

git remote -v

This will display a list of remotes with their URLs, e.g.:

origin  https://github.com/example/repo.git (fetch)
origin  https://github.com/example/repo.git (push)

Push to a Specific Remote

git push --force <remote-name> <branch-name>

• <remote-name> is the name of the remote you want to push to (e.g., origin, upstream, etc).
• <branch-name> is the branch you want to push (e.g., main, master, etc).