Git safety: never amend after hook failure

When a pre-commit hook fails (linting error, formatting issue, test failure), the git commit does NOT happen — it's aborted. A common mistake is to fix the issue and then run 'git commit --amend', thinking you're retrying the failed commit. But --amend doesn't retry — it modifies the PREVIOUS successful commit. If that previous commit was from yesterday's feature work, amending would: (1) merge today's unrelated changes into yesterday's commit, (2) lose yesterday's original commit message, (3) create a confusing git history where one commit contains changes from two different features, and (4) if already pushed, would require a force-push to fix. This is especially dangerous for AI coding agents that automate git operations.

After a pre-commit hook failure, follow this exact workflow:

1. FIX the issue that caused the hook to fail (lint error, format issue, etc.)

1. RE-STAGE the fixed files:

git add <fixed-files>

1. CREATE A NEW COMMIT (never --amend):

git commit -m 'feat: add user authentication'

1. VERIFY the history looks correct:

git log --oneline -3

WHEN --amend IS appropriate (the ONLY valid cases):
- You JUST made a commit (seconds ago) and want to fix a typo in the message
- You JUST made a commit and forgot to include a file
- You explicitly want to modify the most recent commit AND it hasn't been pushed
- The user explicitly asks you to amend

DECISION TREE:
Hook failed?
- Yes -> Fix issue -> git add -> git commit (NEW, no --amend)
- No -> Commit succeeded -> Want to modify it? -> git commit --amend (only if not pushed)

SAFETY CHECK before any --amend:
git log --oneline -1 # verify the last commit is the one you want to modify
git status # verify only intended changes are staged

PRE-AMEND BACKUP (if unsure):
git stash
git log --oneline -3
# only then proceed with --amend if appropriate

'git commit --amend' replaces the last commit entirely — it's not an 'edit', it's a 'delete and recreate.' The new commit gets a different SHA, different timestamp, and combines the old commit's changes with whatever is currently staged. If the last commit is from a completely different context (yesterday's feature), amending silently merges unrelated changes and destroys the original commit's integrity. This is particularly dangerous because: (1) it LOOKS like it worked (no error), (2) the damage isn't obvious until you review history or try to push, and (3) force-pushing to 'fix' it rewrites history for all collaborators.

Recovering from pre-commit hook failures