Recap — The 'Oh No' Toolkit

# The 'Oh No' Toolkit Three commands you'll use weekly: stash, cherry-pick, reset. Each solves a common "oh wait" situation. ## Stash — save uncommitted work temporarily You're in the middle of editing; urgent context switch needed (hotfix on main, etc.). You don't want to commit half-finished work. ```bash git stash # save current changes; revert working tree git stash push -m "feature wip" # with message git stash list # see stashes # stash@{0}: WIP on feature: abc123 Add user model # stash@{1}: On main: hotfix attempt git stash pop # restore latest stash + remove from stash list git stash apply # restore without removing (in case you want to keep it) git stash apply stash@{1} # specific stash git stash drop stash@{0} # remove a stash git stash clear # remove all ``` ### What gets stashed By default: tracked files modifications + staged changes. NOT untracked or ignored files. To include untracked: ```bash git stash -u # include untracked git stash -a # include all (untracked + ignored) ``` ### Common stash mistakes 1. Forgetting you stashed; come back later confused about missing work. 2. `pop` when you have new conflicting changes → confusing conflicts. 3. Stashing on the wrong branch and `pop`ping on another → applies to wrong place. For long-term storage, prefer a branch (`git switch -c wip/temp`) over stash. Stash for quick context switches. ## Cherry-pick — copy a specific commit to another branch You have commit ABC on branch feature; you want it on main without merging feature. ```bash git switch main git cherry-pick abc123 # applies abc123's changes as a new commit on main ``` Result: a NEW commit on main with the same changes. Different SHA (because parent is now different). ### Multiple commits ```bash git cherry-pick abc123 def456 ghi789 # OR range: git cherry-pick abc123..ghi789 # all between ``` ### When useful - Backporting a fix from main to a release branch. - Pulling one commit from a colleague's branch without merging all of it. - Recovering a commit from an abandoned branch. ### When NOT to use - For routine integration — use merge or rebase instead. - When you'd cherry-pick most of a branch — just merge. - When the commit depends on others not on the target — will conflict. ### Cherry-pick conflicts If the commit doesn't apply cleanly: ```bash # Resolve conflicts git add file.txt git cherry-pick --continue # OR abort: git cherry-pick --abort ``` ## Reset — move the branch pointer The most dangerous and misunderstood Git command. Three modes: ### Soft reset ```bash git reset --soft HEAD~1 ``` - Moves branch pointer back by 1. - Working tree: unchanged. - Staging area: unchanged (so the changes are still staged). Use when: you want to undo the LAST COMMIT but keep changes ready to re-commit (maybe split or refine). ### Mixed reset (default) ```bash git reset HEAD~1 # same as git reset --mixed HEAD~1 ``` - Moves branch pointer back by 1. - Working tree: unchanged. - Staging area: reset to match new HEAD (so changes are UNSTAGED). Use when: undo commit AND unstage; review changes before re-staging. ### Hard reset ```bash git reset --hard HEAD~1 ``` - Moves branch pointer back by 1. - Working tree: reset (DISCARDS uncommitted changes!). - Staging area: reset. Use when: you really want to throw away the last commit AND your changes. **Dangerous — uncommitted work is gone.** ### Reset moves to any commit ```bash git reset --soft abc123 # rewind to abc123, keep all changes staged git reset --hard origin/main # match remote main exactly (discard local) ``` ### Reset vs revert — both undo, differently **Reset** moves the branch pointer (rewriting history). **Revert** creates a NEW commit that undoes a previous one (history preserved). ```bash git revert abc123 # create a new commit that undoes abc123 ``` For shared branches: use `revert`. For local cleanup: `reset` is fine. ## Reset summary | Mode | Pointer | Staging | Working tree | |---|---|---|---| | --soft | moves | unchanged | unchanged | | --mixed (default) | moves | resets | unchanged | | --hard | moves | resets | resets | ## Practical scenarios ### Scenario 1: Bad commit; want to redo it ```bash git reset --soft HEAD~1 # un-commit; changes still staged # fix things git commit -m "Better message" ``` ### Scenario 2: Committed to wrong branch ```bash # You committed to main; should've been on feature git switch feature git cherry-pick main # bring that commit here git switch main git reset --hard HEAD~1 # remove from main ``` ### Scenario 3: Pulled and want to undo ```bash git reset --hard ORIG_HEAD # ORIG_HEAD is where you were before pull ``` ### Scenario 4: Working tree is messy; start over ```bash git stash # save changes # or: git