Git Config and Aliases — The 'git st' That Staged Everything

Git aliases are the #1 productivity hack for daily Git users. A well-crafted set of aliases reduces common 5-word commands to 2-3 characters. git co instead of git checkout, git br instead of git branch, git lg for a pretty log output. But aliases come with a trap: if you share aliases (e.g., via a team .gitconfig), different developers may have different interpretations of the same alias. This guide covers the essential aliases, the three config levels and when to use each, and the incident where a shared alias file caused unexpected staging behavior.

Why Customize Git?

Git's default configuration works for basic tasks, but in production, you need consistency, speed, and safety. Customizing Git config and aliases reduces typing errors, enforces team standards, and automates repetitive workflows. Without customization, developers waste time typing long commands, risk committing with wrong user details, and lack guardrails for destructive operations. This section sets the stage for why you should invest 10 minutes to configure Git properly.

git config --global --list

Setting Up Your Git Config

Start with the essentials: user identity, default branch name, and editor. Set init.defaultBranch to main to avoid the outdated master default. Choose a familiar editor like vim or code --wait for VS Code. Enable color.ui for better diff readability. Use git config --global to apply these settings across all repos. Verify with git config --list. For teams, consider a shared .gitconfig file that can be version-controlled.

git config --global user.name "Jane Doe"
git config --global user.email "jane@example.com"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"
git config --global color.ui auto
git config --global pull.rebase true
git config --global fetch.prune true

Creating Your First Aliases

Aliases shorten common commands. Define them in [alias] section of .gitconfig. Start with co for checkout, br for branch, ci for commit, and st for status. Use ! prefix for shell commands. Aliases save keystrokes and reduce typos. For example, git st is faster than git status. Test aliases by running them; they behave like native commands.

[alias]
  co = checkout
  br = branch
  ci = commit
  st = status
  unstage = reset HEAD --
  last = log -1 HEAD
  visual = !gitk

Advanced Aliases for Daily Workflows

Move beyond simple shortcuts. Create aliases for complex operations: git amend to amend last commit without editing message, git lg for a pretty log graph, git wip to quickly stash work-in-progress. Use shell functions for multi-line logic. For example, git wip can add all, commit with a WIP message, and push. These aliases enforce consistent commit patterns and speed up iterative development.

[alias]
  amend = commit --amend --no-edit
  lg = log --graph --oneline --decorate --all
  wip = !git add -A && git commit -m "WIP" && git push
  undo = reset --soft HEAD~1
  cleanup = !git branch --merged | grep -v "\*" | xargs -n 1 git branch -d

Conditional Includes for Work vs Personal

Use includeIf to load different configs based on repo path. This is critical for separating work and personal identities. For example, all repos under ~/work/ use work email and signing key, while personal repos use personal settings. Define a base config with common aliases, then override identity in conditional includes. This avoids accidentally committing with wrong email.

[includeIf "gitdir:~/work/"]
  path = ~/.gitconfig-work

[includeIf "gitdir:~/personal/"]
  path = ~/.gitconfig-personal

Signing Commits with GPG or SSH

Signed commits verify authorship and prevent impersonation. Configure GPG or SSH signing in Git config. Generate a key, add it to GitHub/GitLab, and set commit.gpgsign true or gpg.format = ssh. Use user.signingkey to specify the key. Aliases like git cs for signed commit can enforce signing. Without signing, anyone can fake a commit author.

# GPG signing
git config --global user.signingkey ABCDEF1234567890
git config --global commit.gpgsign true

# SSH signing
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub

Diff and Merge Tools Configuration

Custom diff and merge tools improve code review and conflict resolution. Set diff.tool and merge.tool to tools like vimdiff, meld, or kdiff3. Configure difftool.prompt false to skip prompts. Use aliases like git difftool to launch the tool. For merge conflicts, git mergetool opens the configured tool. This speeds up conflict resolution significantly.

[diff]
  tool = vimdiff
[difftool]
  prompt = false
[merge]
  tool = vimdiff
[mergetool]
  prompt = false

Automating with Hooks and Aliases

Combine aliases with Git hooks for automation. For example, a pre-push hook can run tests, and an alias git push-safe can invoke the hook. Use core.hooksPath to share hooks across team. Aliases can also call scripts: git deploy = !./deploy.sh. This ensures consistent deployment steps. Hooks prevent bad commits from reaching remote.

[alias]
  push-safe = !git push --force-with-lease
  deploy = !./scripts/deploy.sh
[core]
  hooksPath = .githooks

Sharing Config Across Teams

Standardize Git config across your team using a shared .gitconfig file stored in a repository. Use include directive to pull it. For example, [include] path = ~/team-config/.gitconfig. This enforces aliases, signing, and diff tools. Update the shared file and team members pull changes. Avoid overriding personal settings like user.email.

[include]
  path = ~/team-config/.gitconfig

# Personal overrides below
[user]
  email = jane@example.com

Troubleshooting Config Issues

Misconfigured Git can cause subtle bugs. Common issues: wrong user identity, alias conflicts, or broken includes. Use git config --list --show-origin to see where each setting comes from. git config --unset to remove problematic settings. For includes, verify paths exist. Test aliases with git <alias> and check for shell errors. Keep a backup of your config.

# Show all config with origin
git config --list --show-origin

# Test an alias
git st

# Unset a bad setting
git config --global --unset alias.bad-alias

Performance Tuning with Config

Git performance degrades with large repos. Optimize with config: core.preloadindex true for faster status, core.fscache true on Windows, gc.auto 256 to control garbage collection. Use feature.manyFiles true for repos with millions of files. Set protocol.version 2 for faster fetches. These settings reduce command latency by 50% or more.

git config --global core.preloadindex true
git config --global core.fscache true
git config --global gc.auto 256
git config --global feature.manyFiles true
git config --global protocol.version 2

Putting It All Together: A Production Config

Combine all best practices into a single .gitconfig. Include identity, aliases, signing, diff tools, performance settings, and conditional includes. This config is battle-tested in production. Use it as a template and adapt to your needs. Remember to keep personal overrides separate. Share with your team via a Git repo.

[user]
  name = Jane Doe
  email = jane@example.com
[init]
  defaultBranch = main
[core]
  editor = code --wait
  preloadindex = true
  fscache = true
[color]
  ui = auto
[pull]
  rebase = true
[fetch]
  prune = true
[alias]
  co = checkout
  br = branch
  ci = commit
  st = status
  lg = log --graph --oneline --decorate --all
  amend = commit --amend --no-edit
  wip = !git add -A && git commit -m "WIP" && git push
  cleanup = !git branch --merged | grep -v "\*" | xargs -n 1 git branch -d
[diff]
  tool = vimdiff
[difftool]
  prompt = false
[merge]
  tool = vimdiff
[mergetool]
  prompt = false
[commit]
  gpgsign = true
[gpg]
  format = ssh
[user]
  signingkey = ~/.ssh/id_ed25519.pub
[includeIf "gitdir:~/work/"]
  path = ~/.gitconfig-work
[includeIf "gitdir:~/personal/"]
  path = ~/.gitconfig-personal