Backup Code

Backup Code Before Risky Changes

Create a recoverable snapshot of local work before any potentially destructive operation.

When to Use This Skill

• Before git operations that can discard or rewrite work
• Before large sweeping code changes across many files
• Before automated codemods, generator rewrites, or bulk renames
• Before cleanup commands touching untracked files
• Any time rollback confidence is low

Keywords: backup branch, safety checkpoint, stash snapshot, destructive git command, recover changes.

Risky Operations Covered

• git reset --hard
• git clean -fd / git clean -fdx
• git rebase / git rebase --onto
• git restore --source ... --worktree --staged
• git checkout or git switch paths/branches that overwrite local work
• git push --force / git push --force-with-lease
• Large multi-file edits where undo history is insufficient

Prerequisites

• Run from repository root
• Working tree state is inspectable with git status --short
• git is available

Decision Flow

1. If current changes are meaningful and may be needed intact, create a backup branch snapshot.
2. If quick temporary rollback is needed, create a named stash.
3. If operation is highly destructive or uncertain, do both.
4. If no local changes exist, still create a backup branch for pre-operation baseline.

Step-by-Step Workflow

1. Inspect Current State

Run:

git status --short
git branch --show-current

Record:

• Current branch name
• Whether there are tracked modifications
• Whether there are untracked files

2. Create Backup Artifact

Choose one strategy.

Strategy A: Backup Branch Snapshot (recommended)

iso_timestamp="$(date -u +%Y-%m-%dT%H-%M-%SZ)"
current_branch="$(git branch --show-current)"
backup_branch="backup/${current_branch}/${iso_timestamp}"

git switch -c "$backup_branch"
git add -A
git commit -m "chore(codebase): 🔧 create safety backup before risky changes"
git switch "$current_branch"

Use this when you need a durable, auditable checkpoint.

Strategy B: Named Stash Snapshot

timestamp="$(date -u +%Y%m%dT%H%M%SZ)"
stash_name="backup:${timestamp}:before-risky-change"

git stash push --include-untracked -m "$stash_name"

Use this when you need a quick local rollback point.

Strategy C: Maximum Safety (both)

Run Strategy A first, then Strategy B if additional local-only checkpointing is desired.

3. Verify Recovery Paths

For branch backups:

git branch --list "backup/*"

For stash backups:

git stash list --date=local

4. Print Recovery Commands

Branch recovery:

git switch <backup-branch>

Stash recovery:

git stash apply "stash@{N}"

5. Proceed With Risky Operation

Only continue after backup artifact and recovery commands are confirmed.

Completion Criteria

• Backup branch exists, or stash entry exists, or both
• Backup includes all intended tracked and untracked changes
• Recovery command is printed and verified
• Risky operation starts only after all checks pass

Troubleshooting

Notes

• Never use destructive commands before creating at least one checkpoint artifact.
• Prefer backup branch for long-running or high-risk tasks because it survives stash pruning and improves traceability.
• Backup branch naming convention: backup/{branch_name}/{iso_timestamp}.