--- title: "10+ Secret Git Commands That Will Save Hours Every Week" description: "Discover 10+ secret Git commands that will save hours every week! Learn advanced Git techniques for undoing mistakes, managing commits, automating workflows, and optimizing repositories. Perfect for DevOps and GitHub users." author: "Mohammad Abu Mattar" canonical: https://mkabumattar.com/blog/post/10-secret-git-commands-to-save-time --- # 10+ Secret Git Commands That Will Save Hours Every Week ## Introduction As a software engineer, DevOps engineer, or GitHub user, you probably use Git daily. But are you making the most of it? Git is packed with commands that can save you hours of manual work every week. In this guide, we'll look at 10+ lesser-known but very useful Git commands that simplify your workflow and cut out repetitive steps. Each command is grouped by use case, with a real-world scenario for each one so you can apply it immediately. --- ## Undoing changes like a pro ### 1. `git reflog` Recover lost commits. It tracks all actions performed in your repository, including resets and rebases. Use it when you accidentally delete a branch or reset commits and need to recover them. Imagine you are working on a critical feature and accidentally run `git reset --hard`, losing your latest commit. Instead of panicking, you can recover your work by running: ```shell git reflog ``` Find the commit hash of the lost state and recover it with: ```shell git reset --hard ``` Now your work is back! ### 2. `git reset --soft HEAD~1` Undo the last commit but keep the changes. It removes the last commit but keeps the changes staged. Use it when you commit something too soon but don't want to lose your changes. You just committed a file but realized you forgot to add an important change. Instead of creating another commit, you can undo the last commit while keeping your changes staged: ```shell git reset --soft HEAD~1 ``` Now your changes are still staged, and you can amend them! ### 3. `git restore` Revert modified files. It restores modified files to their last committed state. Use it when you accidentally modify or delete files and need to revert them. You mistakenly changed a config file and need to revert it to its last committed state. Instead of re-cloning the repo, you can simply run: ```shell git restore ``` Your file is now back to its last committed version. --- ## Managing branches efficiently ### 4. `git switch` Switch branches quickly. It moves you between branches without the rest of what `git checkout` does. Use it when you are working on multiple features and need to jump between branches frequently. You are working on multiple features and need to switch between branches frequently. Instead of using `git checkout` every time, you can use: ```shell git switch feature-branch ``` Faster and cleaner than `git checkout`! ### 5. `git worktree` Work on multiple branches at the same time. It lets you check out multiple branches in separate directories. Use it when you need to work on multiple branches without switching context. You need to review a PR while working on a feature. Instead of stashing your changes, you can run: ```shell git worktree add ../review-pr feature-branch ``` Now you have both branches available in different directories! ### 6. `git rebase -i HEAD~` Clean up commit history. It rewrites commit history interactively. Use it when cleaning up commit history before merging a branch. Your feature branch has 10 messy commits. Instead of merging them all, you can run: ```shell git rebase -i HEAD~10 ``` Pick, squash, or edit commits for a cleaner history! --- ## Managing commits like a boss ### 7. `git cherry-pick` Apply specific commits to another branch. It copies one commit onto the branch you have checked out. Use it when you need to apply a hotfix from one branch to another. A bugfix commit exists in `dev` but is needed in `main`. Instead of merging everything, you can apply the specific commit: ```shell git cherry-pick ``` ### 8. `git commit --amend` Modify the last commit. It changes the last commit message, or folds more changes into it. Use it when you make a small mistake in a commit. You committed with the wrong message. Instead of creating a new commit, you can amend the last commit message: ```shell git commit --amend -m "Corrected commit message" ``` No need for an extra commit! ### 9. `git range-diff` Compare commit ranges. It diffs two ranges of commits against each other. Use it when reviewing a rebase before pushing changes. Before force-pushing a rebased branch, you want to verify the changes. You can compare the commit ranges: ```shell git range-diff origin/main HEAD ``` That way nothing important gets lost. --- ## Managing the working directory ### 10. `git stash` Save uncommitted changes temporarily. It parks your uncommitted changes and leaves you a clean working tree. Use it when switching branches but keeping your work. You need to check out `main`, but have unfinished work. Instead of committing incomplete changes, you can stash them: ```shell git stash ``` Switch branches, then restore it with: ```shell git stash pop ``` ### 11. `git sparse-checkout` Check out specific parts of a repository. It limits your working tree to the paths you ask for. Use it when dealing with large monorepos. You are working with a large monorepo and only need specific directories. Instead of cloning everything, you can initialize sparse-checkout: ```shell git sparse-checkout init --cone ``` Then include specific folders: ```shell git sparse-checkout set backend/ ``` --- ## Debugging and auditing code ### 12. `git bisect` Find the commit that introduced a bug. It binary-searches your history for the commit that broke things. Use it when debugging regressions. A feature broke, but you don't know when. You can automate the search for the bad commit: ```shell git bisect start ``` Mark bad and good commits, and Git will find the culprit! ### 13. `git blame` Identify who modified each line. It shows who last touched each line in a file, and in which commit. Use it when investigating why a piece of code changed. You found a bug in a file and want to know who last modified it. You can run: ```shell git blame config.yaml ``` Now you know whom to ask! --- ## Conclusion Learn these Git commands and you will save hours every week, mostly by not redoing work you already did once. Whether you are a software engineer, DevOps engineer, or GitHub user, they cover undoing changes, managing branches, tidying up commits, and debugging. --- ## References 1. Pro Git book - Scott Chacon and Ben Straub. [https://git-scm.com/book/en/v2](https://git-scm.com/book/en/v2) 2. Git Documentation - Official Git SCM. [https://git-scm.com/doc](https://git-scm.com/doc) 3. Atlassian Git Tutorial. [https://www.atlassian.com/git/tutorials](https://www.atlassian.com/git/tutorials) 4. `git reflog` - Git SCM. [https://git-scm.com/docs/git-reflog](https://git-scm.com/docs/git-reflog) 5. `git reset` - Git SCM. [https://git-scm.com/docs/git-reset](https://git-scm.com/docs/git-reset) 6. `git restore` - Git SCM. [https://git-scm.com/docs/git-restore](https://git-scm.com/docs/git-restore) 7. `git switch` - Git SCM. [https://git-scm.com/docs/git-switch](https://git-scm.com/docs/git-switch) 8. `git worktree` - Git SCM. [https://git-scm.com/docs/git-worktree](https://git-scm.com/docs/git-worktree) 9. `git rebase` - Git SCM. [https://git-scm.com/docs/git-rebase](https://git-scm.com/docs/git-rebase) 10. `git cherry-pick` - Git SCM. [https://git-scm.com/docs/git-cherry-pick](https://git-scm.com/docs/git-cherry-pick) 11. `git stash` - Git SCM. [https://git-scm.com/docs/git-stash](https://git-scm.com/docs/git-stash) 12. `git sparse-checkout` - Git SCM. [https://git-scm.com/docs/git-sparse-checkout](https://git-scm.com/docs/git-sparse-checkout) 13. `git bisect` - Git SCM. [https://git-scm.com/docs/git-bisect](https://git-scm.com/docs/git-bisect) 14. `git blame` - Git SCM. [https://git-scm.com/docs/git-blame](https://git-scm.com/docs/git-blame) 15. GitHub Guides. [https://guides.github.com/](https://guides.github.com/)