Back up Codex projects safely.

Quick answer for Codex backup

Back up Codex projects whenever the local project reaches a useful state. Codex can help move through code quickly, but the durable copy still needs to live outside one local folder. A private GitHub backup gives you a recovery point before context changes or the next prompt moves the project in a risky direction.

Why Codex projects need a backup step

A productive Codex session can touch routes, components, tests, configuration, and generated assets in one sitting. That speed is useful, but it also means the local folder can become the only place where hours of work exist.

The risk is not only a broken laptop. A prompt can move in the wrong direction, a context window can end, or a user can close a terminal before creating a clean recovery point.

Codex work often happens in bursts. One session may create a working feature; the next may reorganize files, change dependencies, or rewrite generated code. A backup step separates the useful state from whatever experiment comes next.

Common Codex backup moments

• After Codex creates a working feature or test fix.
• Before asking Codex to refactor many files at once.
• Before changing build tools, package scripts, or deployment configuration.
• Before switching from a local agent session to another AI coding tool.
• Before ending the session when the project would be hard to recreate from prompts.

A safer Codex backup workflow

1. Run Codex in the project folder where the files actually live.
2. Run aicodebackup setup once when the project starts to matter.
3. After setup succeeds, run aicodebackup backup after each meaningful change set.
4. Use private GitHub repositories by default so source code is not published accidentally.
5. Use aicodebackup watch to catch long sessions where changes pile up.
6. Run aicodebackup doctor when you are unsure whether the latest work is backed up.

Codex project backup checklist

• Back up after Codex creates a feature you would not want to recreate manually.
• Back up before prompts that mention refactor, rewrite, delete, migrate, or simplify.
• Back up before package, deployment, authentication, or database configuration changes.
• Run aicodebackup doctor before a long session if you have not backed up recently.
• Use aicodebackup watch --auto when many files are likely to change quickly.
• Keep secrets and local-only credentials out of the folder before pushing to GitHub.

What AICodeBackup handles

AICodeBackup is designed for users who need the result of Git without first learning Git vocabulary. It checks the local environment, helps connect GitHub, creates a private repository when needed, and pushes a backup through one command.

• Git and GitHub CLI checks before backup work starts.
• Browser-based GitHub login through GitHub CLI.
• Private repository creation when no remote exists.
• Automatic add, commit, and push for the current project state.

When to back up during a Codex session

Back up before asking Codex to make risky cross-file changes, after a feature starts working, and before ending a long session. The goal is not a perfect history. The goal is a reliable private copy of the work you care about.

Before context changes

Codex users should create a backup before the session changes direction. If you are moving from feature work to cleanup, from frontend to backend, from code edits to deployment, or from one AI tool to another, create a recovery point first. That checkpoint preserves the previous state even if the next round of prompts gets messy.

This is especially useful when the project is being built by a non-traditional developer who may not yet have a habit of committing and pushing after every working change.

Safe restore for Codex projects

If a later Codex session moves the project in the wrong direction, restore into a new folder instead of overwriting the current project. Run aicodebackup restore --list to find recent remote backup commits, then restore to a sibling directory for inspection.

A separate restore folder lets you compare the current project with a known-good backup. You can copy back specific files manually instead of replacing the whole active workspace.

What to do if generated code is lost

1. Stop making more destructive changes in the current folder.
2. Run aicodebackup restore --list to find recent checkpoints.
3. Restore the selected checkpoint into a separate folder.
4. Open both folders and compare the generated files.
5. Copy back the minimum files needed to recover the working state.

FAQ

Does Codex replace project backup?

No. Codex can help create and modify code, but your local project still needs a durable backup path outside the machine and session.

Why private GitHub instead of a public repository?

AI-generated projects can include unfinished ideas, API experiments, and proprietary implementation details. A private repository is the safer default recovery target.

Do I need to learn Git before backing up Codex projects?

No. AICodeBackup uses Git and GitHub under the hood, but the everyday workflow is setup, backup, doctor, watch, and restore.

When is a Codex backup most important?

Back up when the project reaches a useful state and before asking for broad edits. Those are the moments where a recovery point saves the most time.