IBM Bob
Features

Rollback

Automatically version workspace files during AI tasks. Safely explore AI suggestions and experiment with changes, and easily recover from unwanted changes.

What is rollback

Rollback lets you:
  • Safely experiment with AI-suggested changes
    •
  • Easily recover from undesired modifications
    •
  • Compare different implementation approaches
    •
  • Revert to previous project states without losing work
    •

How rollback works

Bob captures snapshots of files during task execution, separate from your main version control system. These snapshots are automatically created before file modifications occur, ensuring you can always undo unwanted changes.

Snapshots are recorded when tasks begin and before file modifications.

Working with rollback

Rollback is integrated directly into your workflow through the chat interface and appears directly in your chat history. Snapshots are created before file modifications, allowing easy undo of any changes.

Each snapshot provides two primary functions that are always available in both the chat history and the rollback menu:

Viewing differences

To see what files changed inside of a task:
  1. After Bob has edited files, the Changed files view will appear collapsed.
    2.
  2. You can click to expand
    3.
  3. Review the differences in the view:
    • Use Show all to see all changes files in a task
    • You can click on a specific file to see the changes
    4.

Restoring a snapshot

Restore options are always visible in rollback buttons and dialogs, regardless of whether changes are detected. This ensures you can always revert to any state.

To restore a project to a previous state:
  1. Hover over any user message and use the rollback button, which will restore the changes files back to the state before that message.
    2.
  2. Click the rollback button on the individual files in the Changes files view. This will let Bob know you reverted a file.
    3.

Limitations

  • Scope: Rollback only captures changes made during active Bob tasks.
    •
  • External changes: Modifications made outside of tasks (manual edits, other tools) are not included.
    •
  • Large files: Very large binary files may affect performance.
    •
  • Unsaved work: Restoration overwrites any unsaved changes in your workspace.
    •
  • Timing: Snapshots are created before changes are applied, providing a safety net for all modifications.
    •
  • Memory usage: Snapshots accumulate over time and can consume significant memory, especially for large projects or long-running tasks. If you have many old tasks with snapshots, consider clearing them periodically to free up memory. You can do this by deleting old task conversations, which removes their associated snapshots.
    •

Technical implementation

Rollback architecture

The rollback system consists of:
  1. Rollback service: Handles file operations and state management through:
    • Snapshot creation and storage
    • Diff computation
    • State restoration
    2.
  2. UI components: Interface elements displayed in the chat that enable interaction with rollback.
    3.

Restoration process

When restoration runs, Bob:
  • Completes a reset to the specified time in a given task.
    •
  • Updates internal rollback tracking state.
    •

Storage type

Rollback is task-scoped, meaning each snapshot is specific to a single task.

Diff computation

Rollback comparison uses Git's underlying diff capabilities to produce structured file differences:
  • Modified files show line-by-line changes.
    •
  • Binary files are properly detected and handled.
    •
  • Rename detection may be limited; diffs focus on file content changes between snapshots.
    •
  • File creation and deletion are clearly identified.
    •

File exclusion and ignore patterns

The rollback system uses intelligent file exclusion to track only relevant files.

Built-in exclusions

The system has built-in exclusion patterns that automatically ignore:
  • Build artifacts and dependency directories (node_modules/, dist/, build/).
    •
  • Media files and binary assets (images, videos, audio).
    •
  • Cache and temporary files (.cache/, .tmp/, .bak).
    •
  • Configuration files with sensitive information (.env).
    •
  • Large data files (archives, executables, binaries).
    •
  • Database files and logs.
    •

.gitignore support

The rollback system respects .gitignore patterns in your workspace:
  • Files excluded by .gitignore do not trigger snapshot creation.
    •
  • Excluded files do not appear in rollback diffs.
    •
  • Standard Git ignore rules apply when staging file changes.
    •

.bobignore behavior

The .bobignore file (which controls AI access to files) is separate from rollback tracking:
  • Files excluded by .bobignore but not by .gitignore are still captured by rollback.
    •
  • Changes to AI-inaccessible files can still be restored through rollback.
    •

This separation is intentional. .bobignore limits which files the AI can access, not which files should be tracked for version history.

How is this topic?

Bob tips

Bob tips detects code quality issues in real-time with AI-powered refactoring suggestions for complex functions. Reduce technical debt as you code.

Code actions

Access Bob's AI-powered code actions that provide quick fixes, refactorings, and code explanations directly in the Bob IDE through lightbulb icons and context menus.

On this page

What is rollbackHow rollback worksWorking with rollbackViewing differencesRestoring a snapshotLimitationsTechnical implementationRollback architectureRestoration processStorage typeDiff computationFile exclusion and ignore patternsBuilt-in exclusions.gitignore support.bobignore behavior