Speed up your Git workflow with these handy aliases. Each alias can be added via command line or directly to your .gitconfig file.
Scenario: You apply a stash but there's a merge conflict. You want to discard all changes so that you can start from a blank slate.
Note that this will discard staged changes, so only use this if you're prepared to discard everything.
git abort-stash
git config --global alias.abort-stash "!git reset --merge"[alias]
abort-stash = !git reset --mergeApply a stash by searching for a partial match in the stash message. Instead of remembering stash numbers, you can use part of the stash description to apply the correct stash. For example, git apply-stash config will apply the most recent stash with "config" in its message.
git apply-stash <partial-name>
git config --global alias.apply-stash "!f() { stash=$(git stash list | grep -i "$1" | head -n 1); if [ -n "$stash" ]; then stash_id=$(echo "$stash" | awk -F: '{print $1}'); echo "Applying $stash"; git stash apply "$stash_id"; else echo "No stash found matching: $1"; fi; }; f"[alias]
apply-stash = !f() { stash=$(git stash list | grep -i "$1" | head -n 1); if [ -n "$stash" ]; then stash_id=$(echo "$stash" | awk -F: '{print $1}'); echo "Applying $stash"; git stash apply "$stash_id"; else echo "No stash found matching: $1"; fi; }; fCreate a new local branch and check it out immediately.
git b feature/new-feature
git config --global alias.b "checkout -b"[alias]
b = checkout -bList all local branches.
git bs
git config --global alias.bs "branch --list"[alias]
bs = branch --listCheckout the dev branch and pull the latest changes from the remote. This is a quick way to switch to your main development branch and ensure you have the latest code before starting new work or reviewing changes.
git cdp
git config --global alias.cdp "!git checkout dev && git pull"[alias]
cdp = !git checkout dev && git pullCheck out a branch.
git co target-branch
git config --global alias.co "checkout"[alias]
co = checkoutStage all changes (including new files, modifications, and deletions) and open the commit message editor. This is a quick way to commit all your work from the command line without having to run separate git add and git commit commands.
git com "commit message here"
git config --global alias.com "!git add -A && git commit -m"[alias]
com = !git add -A && git commit -mOpen your git config in your default editor so you can easily review and update it. Save any changes you make, then close the text editor when you're finished. This command will not finish until you close the text editor.
git conf
git config --global alias.conf "config --global -e"[alias]
conf = config --global -eList all files that currently have merge conflicts. This is helpful during merge or rebase operations to quickly see which files need conflict resolution, without having to parse through the full output of git status.
git conflicts
git config --global alias.conflicts "!git ls-files --unmerged | cut -f2 | sort -u"[alias]
conflicts = !git ls-files --unmerged | cut -f2 | sort -uCheck out a branch by a partial branch name. This function searches for branches containing the provided pattern and checks out the first match.
I name branches with a reference to a work item number, then use the work item number to checkout the right branch. For example, the branch might be called feature/12345-updated-invoice-structure and I can check it out with git cop 12345 or git cop invoice.
From Stack Overflow.
git cop 12345
git config --global alias.cop "!f() { git branch -a | grep -m1 -e ${1}.*${2} | sed "s/remotes\/origin\///" | xargs git checkout; }; f"[alias]
cop = !f() { git branch -a | grep -m1 -e ${1}.*${2} | sed "s/remotes\/origin\///" | xargs git checkout; }; fCheckout a release branch based on a releases/sprint-x naming convention, and pull the latest changes from the remote. Similar to the cdp alias but for the release branch, this quickly switches you to the release branch and ensures you have the most up-to-date code.
git cor 198.3
git config --global alias.cor "!f() { git checkout releases/sprint-$1 && git pull origin releases/sprint-$1; }; f"[alias]
cor = !f() { git checkout releases/sprint-$1 && git pull origin releases/sprint-$1; }; fDelete a local branch. Use with caution as this permanently deletes the branch, even if it hasn't been merged.
git db unwanted-branch
git config --global alias.db "branch -D"[alias]
db = branch -DMerge latest dev branch code into your current branch and update your local dev branch. Assumes you have a branch called dev both locally and on the origin remote. This alias is useful for keeping your feature branches up-to-date with the latest development work.
This alias pulls the latest dev branch from origin, merges it into your current branch, and updates your local dev branch to match origin/dev.
git dev
git config --global alias.dev "!git pull origin dev && git merge dev && git fetch origin dev:dev"[alias]
dev = !git pull origin dev && git merge dev && git fetch origin dev:devSwitch from a feature branch to the latest code in dev branch, and delete branches which are fully merged into dev branch. This alias is intended for use after pushing a code-complete feature branch to the server, when ready to start a new feature based on the latest dev branch code.
git done
git config --global alias.done "!git fetch && git checkout dev && git pull && git merged && git status"[alias]
done = !git fetch && git checkout dev && git pull && git merged && git statusFetch latest changes from the server and remove references to deleted remote branches.
git f
git config --global alias.f "fetch --prune"[alias]
f = fetch --pruneDelete local branches which have been fully merged into dev branch (excluding the dev branch itself). Useful for cleaning up completed feature branches.
From Advanced Git Aliases published by Atlassian.
git merged
git config --global alias.merged "!f() { git branch --merged dev | grep -v " dev$" | xargs -r git branch -d; }; f"[alias]
merged = !f() { git branch --merged dev | grep -v " dev$" | xargs -r git branch -d; }; fDelete all local branches that have been fully merged into the specified branch. Similar to the merged alias but allows you to specify any branch name as the target. For example, git merged-into main will delete all branches merged into main.
git merged-into <branch-name>
git config --global alias.merged-into "!f() { git branch --merged "$1" | grep -v " $1$" | xargs -r git branch -d; }; f"[alias]
merged-into = !f() { git branch --merged "$1" | grep -v " $1$" | xargs -r git branch -d; }; fRun npm ci in all directories that contain a package.json file. This is useful in monorepo setups or projects with multiple npm packages, allowing you to install all dependencies in a single command with clean installs.
git npmci
git config --global alias.npmci "!f() { git ls-files "*/package.json" | sed "s|/[^/]*$||" | sort -u | xargs -I {} sh -c "echo 'Running npm ci in {}' && cd {} && npm ci"; }; f"[alias]
npmci = !f() { git ls-files "*/package.json" | sed "s|/[^/]*$||" | sort -u | xargs -I {} sh -c "echo 'Running npm ci in {}' && cd {} && npm ci"; }; fRun npm install in all directories that contain a package.json file. Similar to npmci but uses npm install instead of npm ci, allowing package-lock.json to be updated if needed. Useful for updating dependencies across multiple packages in a monorepo.
git npmi
git config --global alias.npmi "!f() { git ls-files "*/package.json" | sed "s|/[^/]*$||" | sort -u | xargs -I {} sh -c "echo 'Running npm i in {}' && cd {} && npm i"; }; f"[alias]
npmi = !f() { git ls-files "*/package.json" | sed "s|/[^/]*$||" | sort -u | xargs -I {} sh -c "echo 'Running npm i in {}' && cd {} && npm i"; }; fOpen a file in Notepad++ directly from the Git command line.
Open the first file whose filename (not path) contains the specified search term.
Intended usage is for a complete or partial file name - does not match against directory names.
File is opened in Notepad++ and the alias assumes this is installed in C:/Program Files/Notepad++
Tested in powershell, command prompt, and git bash.
Explanation:
root is the file path to the git repository.
file is the file path within the repository for the first file found matching the search term.
Uses grep/findstr to match only against the basename (filename) portion of the path, not directories.
Checks if grep is available and uses it, otherwise falls back to a Windows-compatible approach.
Validates that a file was found before attempting to open it.
Calculates root and file, then starts notepad++.exe and passes the absolute file path in.
Note that it uses start so that the command finishes executing without waiting for notepad++ to close.
git open ExportFxTransactionCommand.cs
git config --global alias.open "!f() { root=$(git rev-parse --show-toplevel); if command -v grep >/dev/null 2>&1; then file=$(git ls-files | grep -m1 "/[^/]*$1[^/]*$"); else file=$(git ls-files | findstr /R "[^/]*$1[^/]*$" | head -1); fi; if [ -n "$file" ]; then start "" "C:\Program Files\Notepad++\notepad++.exe" "$root/$file"; else echo "No file found matching: $1"; fi; }; f"[alias]
open = !f() { root=$(git rev-parse --show-toplevel); if command -v grep >/dev/null 2>&1; then file=$(git ls-files | grep -m1 "/[^/]*$1[^/]*$"); else file=$(git ls-files | findstr /R "[^/]*$1[^/]*$" | head -1); fi; if [ -n "$file" ]; then start "" "C:\Program Files\Notepad++\notepad++.exe" "$root/$file"; else echo "No file found matching: $1"; fi; }; fPull latest changes. Shorthand for git pull to fetch and merge changes from the upstream branch. Added for consistency with the 2-character ps alias.
git pl
git config --global alias.pl "pull"[alias]
pl = pullPush commits to a remote branch on the origin remote. If there is no upstream branch on origin, one will be created.
I prefer this alias to running git push because it works regardless of whether or not there is an existing upstream branch.
git ps
git config --global alias.ps "push -u origin HEAD"[alias]
ps = push -u origin HEADPush up to a specific commit. This function pushes the current branch up to a specific commit hash. My main use case for this is when making changes to a branch which already has a Pull Request in Azure DevOps. The changes in each push can be reviewed as separate updates to the PR, so I can make a series of commits then push them as multiple logical updates for easier review.
I based this alias on https://coderwall.com/p/hexinq/git-push-up-to-a-certain-commit
git pt abc123
git config --global alias.pt "!f() { BRANCH=`git symbolic-ref --short HEAD`; git push -u origin ${1}:refs/heads/$BRANCH; }; f"[alias]
pt = !f() { BRANCH=`git symbolic-ref --short HEAD`; git push -u origin ${1}:refs/heads/$BRANCH; }; fRename the current branch.
git rename-branch new-branch-name
git config --global alias.rename-branch "branch -m"[alias]
rename-branch = branch -mQuick shorthand for git status to quickly check the current state of your working directory and staging area.
git s
git config --global alias.s "status"[alias]
s = statusSquash commits from the current branch into another branch. This function takes all commits from the current branch and squashes them into a single commit on the target branch. The result is not committed automatically, allowing you to review and write a commit message.
Modified from https://stackoverflow.com/a/37209562/4051181.
Usage: while on 'wip/12345', wanting to squash everything into 'feature/12345', run 'git squash feature/12345'.
git squash feature/12345
git config --global alias.squash "!f() { BRANCH=`git symbolic-ref --short HEAD`; git checkout ${1}; git merge --squash $BRANCH; }; f"[alias]
squash = !f() { BRANCH=`git symbolic-ref --short HEAD`; git checkout ${1}; git merge --squash $BRANCH; }; fStages all changes (including new, modified, deleted, and renamed files) and applies the latest stash. Intended usage is when starting a project where configuration changes are stored in a stash. Before starting the application, we want to apply the latest stash containing the word 'config' but keep them separate from the changes under test (which is why they are staged).
git start
git config --global alias.start "!git add -A && git apply-stash config"[alias]
start = !git add -A && git apply-stash configStash current changes, suffixing the provided message with the word 'config' and the current date & time.
For example, running git stash-config "MyApp working" could create a stash called MyApp working config 2025-12-04 09:37.
git stash-config "MyApp working"
git config --global alias.stash-config "!f() { git stash -u -m "$1 config $(date +%Y-%m-%d' '%H:%M)"; }; f"[alias]
stash-config = !f() { git stash -u -m "$1 config $(date +%Y-%m-%d' '%H:%M)"; }; fReverts all unstaged changes to tracked files, and delete all untracked files and directories. Intended usage is when stopping a project where configuration changes are stored in a stash. When we stop the application, we want to revert the unstaged changes (which we are expecting to just be the configuration changes) so we have a clean working directory.
git stop
git config --global alias.stop "!git checkout -- . && git clean -fd"[alias]
stop = !git checkout -- . && git clean -fdUndo the latest commit, removing the commit from history and leaving the changes from the commit unstaged.
git uncommit
git config --global alias.uncommit "reset --mixed HEAD~1"[alias]
uncommit = reset --mixed HEAD~1View commits on the current local branch which have not yet been pushed to the server.
git unpushed
git config --global alias.unpushed "cherry -v"[alias]
unpushed = cherry -v