Common Workflows

In this page you can find what are the most common workflows with Rover, and how you can take advantage of them. There are three main kind of workflows at this time:

Initialization: initializing a repository with Rover is the prerequisite for the rest of the workflows.
Task creation and iteration: the core features of Rover when it comes to implementing new functionalities, or refining existing ones.
Inspection and debugging: for changeset inspection, testing and debugging.

Initialization

Initializing Rover in a repository is the first step and a prerequisite to use it.

Configuration and state files

Rover has two different set of configuration and state files. All of them are stored under your project repository:

.rover: this directory contains settings that are related to user preferences, such as what is your preferred agent. Not meant to be checked in git.
rover.json: this file contains project settings, such as what are the languages in this repo, what package manager it uses, and whether commits should include agent attribution. Meant to be checked in git.

There are two types of initialization: from scratch, and when a repository was cloned with a pre-initialized rover.json, in which case only the .rover directory needs to be populated.

Initialization

The command required to initialized the repository is the same in both cases: rover init.

Initializing Rover from scratch

1
Navigate to a project in which you want to enable Rover. This project needs to have git initialized, and at least one commit has to exist in its history.
Terminal window
```
mkdir -p ~/rover-quickstart && cd ~/rover-quickstart && git init && \
  touch README.md && git add README.md && git commit -a -m 'Initial commit'
```
2
Init Rover
Terminal window
```
rover init -y
```
Rover will detect all supported installed agents in your system. You can init Rover in as many projects as you wish.
3

Rover is fully initialized!

Had you cloned a Rover pre-initialized repository, you just need to init it locally after cloning:

Initializing Rover on a Rover pre-initialized repo

1
Clone your project that has already been initialized by Rover:
Terminal window
```
git clone [email protected]:myorg/myrepo.git && cd myrepo
```
2
Init Rover
Terminal window
```
rover init -y
```
Rover will detect all supported installed agents in your system. You can init Rover in as many projects as you wish.
3

Rover is fully initialized!

Task creation and iteration

The main concept of Rover are tasks. Tasks can be as complex and big as needed, however, if you request smaller tasks or concise ones and with pointers, it will be easier for the agent to figure out how to implement them, but they can be whatever you want, so… try them out and experiment to find out how they best fit your needs!

Every task in Rover has its own git worktree. By doing this, Rover is able to work on multiple tasks in parallel without them conflicting with each other, or with your own work.

Task Creation

Ask Rover to create a simple task from scratch on an empty repository.

Task Creation

1
Navigate to a project that was previously initialized with Rover
Terminal window
```
cd ~/my-project
```

You can ask Rover to create a program, for example fizzbuzz

rover task -y "Create a fizzbuzz bash program as a programming example"

3
You can follow the progress of all tasks by watching the task list
Terminal window
```
rover list -w
```
You can also follow the newly created task progress by following its logs. Assuming it got a Task ID of 1, you can:
Terminal window
```
rover logs -f 1
```

You might be happy with the first implementation of this task made by the agent, but in most situations, you will want to refine what it did. In order to accomplish this, Rover has iterations of a task.

Iterations

Iterations are another core concept of Rover: you can have as many iterations as you need as part of a task. They reflect the interaction between you, and the agent with regards to a specific task. Whenever you ask Rover to create a new iteration on a task, the rest of the iterations will be taken into account and will be part of the context of the overall task, leading to the final result — the last iteration.

Task Iteration

1
Following the previous example, we can ask an iteration of that task. We want all text to be printed to screen to be done in FIGlet style.
Terminal window
```
rover iterate 1 "Update all output to use the figlet style"
```
2
As with task creation, you can follow the logs of the iteration as it is happening. The task number does not change with new iterations.
Terminal window
```
rover logs -f 1
```

Inspect agent proposed plan

Besides listing the current tasks, or watching the listing, you can also inspect tasks and their iterations.

Inspecting tasks

1
Inspect a task. This will provide you some information about the task, the iterations, and the files that describe the iteration.
Terminal window
```
rover inspect 1
```
2
If the previous step lists a plan.md file in the iteration details, we can check its contents
Terminal window
```
rover inspect 1 --file plan.md
```

Besides the plan, you can also check for the context.md, changes.md and summary.md documents that represent: the context of the change, what are the changes that need to be implemented, and the summary with all the changes that were made by the agent.

Inspecting, testing, trying and debugging

Test, try and debug

There are multiple ways to check what code diffs the agent is proposing. The most straightforward one is to ask Rover for a diff of the changes.

Check proposed diff

1
Terminal window
```
rover diff 1
```

Check the command reference to learn more about what extra arguments and parameters the rover diff command supports.

Try agent proposed changes

In order to try the proposed changes, you have to cd into the git worktree path. Rover allows you to do this by the command rover shell. By default, rover shell will use your current $SHELL to spawn a new instance on the worktree of the task as the current working directory of the new process.

Try proposed changes

1
Terminal window
```
rover shell 1
```
2
In this task creation run, the agent created a fizzbuzz.sh file that we can try on the shell. Your mileage may vary.
Terminal window
```
sh fizzbuzz.sh
```

Within the workspace you can also use git normally. The only special circumstance is that the system is inside a git worktree.

In this environment is also perfectly fine to run tests and perform checks which ensure the quality of the overall changeset.

Improve and complete agent changes

If the agent has produced a result that needs some small changes to be ready, you can add those changes directly to the worktree. Let’s assume that we want to add a Version: 1.0 string on the fizzbuzz.sh output.

Improve proposed changes

1
Terminal window
```
rover shell 1
```
2
Edit the file, perform the required changes and save it
Terminal window
```
$EDITOR fizzbuzz.sh
```

Commit your changes

git commit -a -m 'chore: add version number to the output'

4

It depends on your shell, but usually you can exit the shell environment by writing exit or with the Ctrl+d key combination

Integrating generated code

Merge, push

Rover does not dictate how you should work with git, it just tries to help you with your own workflow. Following this principle, you might want to merge proposed changes directly to a branch, or push the branch to a remote.

Merge proposed changes directly to a branch

Merge proposed changes to the current branch

1
You can merge a task branch in completed status by using rover merge
Terminal window
```
rover list
```
2
Terminal window
```
rover merge 1
```

Push branch to a remote

Push branch to the remote

1
You can push the working branch to the remote repository. If there are remaining uncommitted changes, you will be asked whether you want to commit them.
Terminal window
```
rover list
```
2
Terminal window
```
rover push 1
```

Other Resources

VSCode Extension

Integrate Endor with VSCode to never leave your favorite IDE in order to get agentic help.

VSCode Extension →

Command Reference

Exhaustive Rover command reference.

Command Reference →

Overview

Rover Overview.

Overview →

Quickstart

Experiment hands-on with Rover on your own projects or start with an empty one.

Quickstart →