git init

Initializes the .git directory so Git can track history. Use it only once per project directory.

git clone https://example.com/org/project.git

Copies the full history and sets up the default `origin` remote. Replace the URL with your repository.

git remote -v

Shows the fetch/push URLs tied to each remote so you can confirm you are pushing to the right place.

git status --short

Shows staged (`A`/`M`) and unstaged changes side by side so you know exactly what will commit.

git add -p

Walks through each change hunk so you can include only the lines that belong in the next commit.

git reset HEAD src/app.ts

Removes src/app.ts from the index but keeps the working copy intact, reversing an accidental `git add`.

git config --global credential.helper osxkeychain # or wincred/libsecret

Leverages the operating system’s secure storage so you do not re-enter passwords every push.

git config --global credential.helper "cache --timeout=3600"

Keeps credentials in memory for an hour—useful on shared machines where permanent storage is risky.

git credential reject <<EOF
protocol=https
host=github.com

EOF

Forces Git to prompt next time. Replace host/protocol as needed.

git config --global user.name "Taylor (Work)"
git config --global user.email "[email protected]"

Applies to every repository on this machine unless overridden locally.

git config user.name "Taylor (Work)"
git config user.email "[email protected]"

Overrides the global identity for the current repository only.

git config --show-origin --get-regexp "^user"

Shows where values were defined (system, global, local).

git status -sb

Shows tracked, untracked, and staged files with a concise summary before you commit.

git add src/components/Button.tsx

Stage only src/components/Button.tsx (repeat per path) so this commit stays focused. Use `git add -p` to review hunks interactively.

git commit -m "Explain what this change does"

Write subject lines like "Explain what this change does": imperative mood, < 72 characters. Add body text with `-m` again or your editor if needed.

git add src/missing-file.ts

Stage src/missing-file.ts (or any other files) so they join the last commit.

git commit --amend

Opens your editor with the previous message prefilled so you can update it.

git revert <commit-sha>

Runs the inverse of the target commit and creates a new revert commit. Great for public branches.

git revert -m 1 <merge-commit-sha>

Use `-m` with the parent number the merge should keep (usually 1 for the main branch).

git restore src/app.ts

Replaces the working tree version with the version from the current branch head.

git restore --staged src/app.ts

Removes the file from the index so it will not be committed, leaving worktree changes intact.

git rebase -i HEAD~3

Opens the last 3 commits in your editor. Change `pick` to `squash` or `fixup` for commits you want to combine.

git rebase --continue

After resolving conflicts (if any), continue until the rebase completes.

git rebase -i <base-commit>^

Replace `<base-commit>` with the commit that precedes the runs you want to squash. Using `^` opens the todo list starting at the first commit you intend to keep separate.

# In the todo list change lines to
pick 1234567 First commit to keep
squash 89abcde Middle commit
squash fedcba9 Final commit to collapse

Change `pick` to `squash` (or `fixup`) for every commit you want folded into the previous one. Leave later commits as `pick` so they replay normally.

git rebase --continue

After resolving conflicts (if any), edit the combined commit message and continue replaying the remainder of history.

git rebase -i HEAD~5

Opens an editor where you can reorder commits and choose actions (pick, reword, edit, squash, fixup, drop) for the last 5 commits.

git rebase -i HEAD~5 # mark commit as edit
git commit --amend
git rebase --continue

Pause on the selected commit, amend it, then continue replaying the rest of the branch.

git rebase -i HEAD~5 # mark commit as edit
git reset HEAD^
# create new commits
git add <subset> && git commit -m "Part 1"
# repeat for remaining changes
git commit -am "Part 2"
git rebase --continue

Reset the commit and create new commits for each logical chunk before continuing the rebase.

# In the todo list change `pick` to `drop` (or delete the line)

Removes the commit entirely. Only safe on branches that are not yet shared.

git checkout -b feature/awesome-change

Creates the branch and moves your HEAD to it in one step.

git switch main

Changes the working tree to match `main`. Use `git switch -c` to create a new branch.

git fetch origin && git checkout main && git pull --ff-only

Make sure your base branch has the latest remote commits before merging.

git merge --no-ff feature/awesome-change

Creates a merge commit so the feature branch history stays visible.

git merge --no-commit --no-ff feature/branch

Applies the merge but leaves the index/working tree staged so you can inspect or test before committing.

git merge --abort

Restores the pre-merge state if tests fail or the merge is not desired.

git commit

Finalizes the merge once you are satisfied with the staged result.

git restore --source feature/login -- src/app/Login.tsx

Copies the file from the source branch into your working tree and stages it for commit.

git restore --source abc1234 -- src/components

Pulls specific paths from a commit (given by SHA) without touching other files.

git checkout feature/login -- src/app/Login.tsx

Same effect using legacy syntax—still handy when working on older Git versions.

git fetch origin main

Fetch the latest commits so you have an up-to-date rebase target.

git rebase origin/main

Applies your commits onto the latest `origin/main`. Resolve conflicts and continue with `git rebase --continue`.

git config --global pull.rebase true

Optional: makes `git pull` default to rebasing instead of merging.

git pull --rebase origin main

Fetches and rebases in one command. Resolve conflicts and continue with `git rebase --continue` if needed.

git fetch origin

Downloads remote updates into your local tracking branches so you can inspect them before integrating.

git fetch origin --prune

Removes local references to remote branches that no longer exist, keeping `git branch -r` tidy.

git pull --rebase origin main

Fetches and rebases in one step to avoid merge commits. Swap `--rebase` for `--ff-only` if you prefer merges.

git remote -v

Shows each remote’s fetch and push URL—use this to verify where work is going.

git remote add upstream https://example.com/org/project.git

Adds a remote pointing to another repository (commonly `upstream` for forks).

git remote set-url origin [email protected]:org/project.git

Changes the remote endpoint—handy when switching from HTTPS to SSH or migrating hosting providers.

git fetch origin

Downloads the latest commits without changing your working tree so you can rebase against an up-to-date target.

git rebase origin/main

Replace `main` with your branch name. Resolve conflicts, then `git add` the files and run `git rebase --continue` until the rebase finishes.

git push

After a successful rebase the remote is behind your rewritten commits, so a normal push fast-forwards it. Use `--force-with-lease` only if teammates may have based work on your branch.

git log --oneline --graph --decorate --all

Shows branches, tags, and commit messages in a single concise view.

git blame app/models/user.rb

Outputs the commit, author, and timestamp for each line in app/models/user.rb.

git blame -L 42,+1 -- src/app.ts

Shows the commit and author responsible for the given line range in src/app.ts.

git blame --reverse -- src/app.ts

Highlights commits that introduced or removed lines in src/app.ts—useful during large refactors.

git log -S"deprecatedFunction" -- src/app.ts

Lists commits where the exact string was added or removed in src/app.ts, narrowing down regressions.

git tag -a v1.2.0 -m "Release v1.2.0"

Annotated tags store metadata (author, date, message) and are best for releases.

git tag --list

Displays all tags in the repository so you can confirm versions.

git tag -a v1.2.0 <commit-sha>

Creates an annotated tag pointing to the given commit—useful when you are tagging a release retroactively.

git push origin v1.2.0

Publishes the tag to collaborators. Use `git push --tags` to send all local tags.

git checkout main
git pull --ff-only origin main

Start from the latest main branch to avoid releasing stale code.

git tag -a v2.3.0 -m "Release v2.3.0" && git tag -v v2.3.0 # optional verification

Annotated (and optionally signed) tags capture release metadata and can be verified later.

git push origin main
git push origin v2.3.0

Publishes the release commit and tag. Use `git push --tags` if pushing multiple tags.

git log v2.2.0..v2.3.0 --oneline --no-merges

Summarize the changes since the prior tag for changelog or release notes.

git describe --tags

Prints the nearest tag plus the number of commits and abbreviated SHA (e.g., v1.2.0-5-gabc1234).

git describe --tags --match "v*"

Restricts matches to tags starting with v (or any glob) when multiple tagging schemes exist.

git describe --tags HEAD^

Generates an identifier for a specific commit, useful in CI pipelines.

git archive --format=tar --output=release.tar HEAD

Generates a tarball of the current tree—great for handing off to build systems or clients.

git archive --format=zip --output=frontend.zip HEAD apps/web

Exports just the given directory from the repo, leaving the rest out of the package.

git bundle create hotfix.bundle main feature/hotfix-123

Packages the necessary commits so another machine can fetch them without network access.

git revert <commit>

Adds a new commit that undoes the target without rewriting history—safe for shared branches.

git reset --mixed HEAD~1

Moves HEAD back and keeps changes in the working tree so you can restage or split commits before pushing.

git rebase -i origin/main

Interactive rebase cleans up local commits before you share them. Use only when collaborators are not using the branch.

git filter-repo --path secrets.txt --invert-paths

Strips `secrets.txt` from every commit. Run in a fresh clone and force push when finished.

git filter-repo --strip-blobs-bigger-than 10M

Deletes blobs larger than 10 MB anywhere in history—helpful when repos grow unexpectedly.

git filter-repo --mailmap my-mailmap.txt

Applies a mailmap to fix historical author/committer details.

git gc --prune=now --aggressive

Cleans up unreachable objects immediately—run after filter-repo or massive branch deletions.

git repack -Ad

Rewrites packfiles, removing duplicates and shrinking repo size on disk.

git reflog expire --expire=now --all

Drops reflog entries so gc can reclaim objects that would otherwise be retained.

# Example: rotate via cloud CLI
aws iam update-access-key --access-key-id <old> --status Inactive

Replace exposed tokens/keys in upstream systems to prevent unauthorized use.

gh workflow run purge-cache.yml --ref main # example

Ensure CI/CD caches or images that contained the secret are purged or rebuilt.

git push --force origin main
# Communicate: everyone must run
git fetch --all && git reset --hard origin/main

After rewriting history, make sure every clone updates to the new canonical history.

git commit -S -m "Secure commit"

Uses your configured GPG or SSH signing key to add a signature to the commit.

git log --show-signature -1

Displays signature status so reviewers can confirm authenticity.

git notes add -m "Deployment checklist" <commit>

Attaches additional metadata to a commit without modifying the commit itself.

git bisect start

Begins a binary search session.

git bisect bad

Tells Git the current revision contains the bug.

git bisect good <commit-sha>

Provide a commit where the bug did not exist. Git will then checkout the midpoint.

git bisect run ./scripts/test-regression.sh

Runs the script at every step; bisect marks commits good/bad depending on the exit code (0 = good).

git stash push -m "WIP: refactor dashboard"

Saves staged and unstaged tracked files. The message helps recall the stash later.

git worktree list

Shows every attached worktree, their paths, and which commit/branch each path checks out.

git worktree add ../feature-login feature/login

Creates a sibling directory at `../feature-login` and checks out the `feature/login` branch there. Use `-b new-branch` to create a branch at the same time.

git worktree remove ../feature-login

Detaches the worktree and deletes that working directory once it is clean. Run `git worktree prune` to clean up stale metadata.

git submodule add https://github.com/org/lib.git libs/lib

Registers the external repo and records its commit pointer in `.gitmodules` and the index. Commit those changes after verifying the checkout.

git submodule update --init --recursive

Clones missing submodules and checks out the recorded commit for each module, including nested modules.

git submodule update --remote --merge

Fetches latest changes for each submodule, checks out the configured branch, and merges the remote updates so you can review them.

git submodule foreach --recursive "git checkout --detach"

Ensures each submodule is in a detached state so the branch can be checked out in only one worktree.

git worktree add ../feature-worktree feature/payment-refactor

Adds another working directory for the branch while submodules remain detached.

git submodule foreach --recursive "git checkout main"

Once extra worktrees are removed, return submodules to their tracking branches.

git stash list

Shows stash entries with their index and messages.

git stash apply stash@{0}

Applies the newest stash (index 0) or any other by number.

git reset --soft HEAD~2

Leaves all changes staged so you can create a new commit immediately.

git reset HEAD~1

Default (mixed) mode: moves HEAD back one commit and unstages those changes, leaving them as modifications.

git reset HEAD src/app.ts

Removes src/app.ts from the index but preserves working tree edits so you can recommit selectively.

git fetch origin && git reset --hard origin/main

Aligns your branch with the remote exactly. Any local changes are lost.

git clean -nd

Lists untracked files and directories that `git clean` would delete, without removing them.

git clean -f

Deletes untracked files (not directories). Always preview first so you know what will disappear.

git clean -fd

Deletes untracked files and directories—useful for wiping build artifacts or vendor folders.

git reflog

Shows every commit your HEAD pointed to recently, including before resets, rebases, or checkouts.

git reset --hard HEAD@{2}

Moves HEAD, the index, and the working tree back to a known-good entry from the reflog. Adjust the index number as needed.

git checkout -b rescue HEAD@{1}

Creates a new branch pointing at a reflog commit so you can merge or cherry-pick the recovered work.

git status --short --branch

Shows whether HEAD is attached to a branch (`## main`) or detached at a specific commit.

git checkout -b experiment-fix

Attaches HEAD to a new branch at the current commit so further commits are preserved.

git switch main

Moves HEAD back to a named branch once you are done reviewing or experimenting.

git status

Lists files with conflict markers (`both modified`) so you know exactly what needs attention.

git merge --abort

Restores the pre-merge state. Use `git rebase --abort` during rebases when conflicts are too complex to resolve immediately.

git add src/app.ts && git commit

Stage src/app.ts after resolving conflicts, then complete the merge or rebase to record the reconciled result.

git cherry-pick <commit-sha>

Applies the given commit on top of your current branch.

git cherry-pick --continue

Creates the cherry-picked commit once you have resolved conflicts and staged the fixes.

git cherry-pick --abort

Stops the cherry-pick and restores the working tree to the state before it began.

git lfs install

Configures your repository (and global Git) to use the LFS smudge/clean filters.

git lfs track "*.psd"

Adds patterns to `.gitattributes` so matching files are stored as lightweight pointers in Git history.

git add .gitattributes && git commit -m "Track design assets with LFS"

Ensures teammates automatically use LFS when they clone the repository.

git clone --depth 1 https://example.com/org/project.git

Downloads just the newest snapshot—ideal for disposable CI environments.

git clone --depth 1 --filter=blob:none https://example.com/org/project.git

Skips large blobs while still fetching recent history—great for enormous repositories in CI.

git fetch --depth 10 origin main

Fetches additional history without recloning when you need a bit more context.

git fetch --unshallow

Downloads the rest of the history so advanced commands like `git log` or `git blame` behave normally again.

git sparse-checkout init --cone

Initializes sparse checkout using cone mode, which is simpler for directory-based selections.

git sparse-checkout set apps/web services/api

Syncs the working tree so only the specified paths appear, speeding up builds and tooling.

git sparse-checkout disable

Restores the entire repository contents if you need full context again.