---
title: "Leveraging Rovo Dev for Development, Testing, and Project Management"
canonical: "https://docs.getxray.app/space/XRAYCLOUD/1392410654/Leveraging%20Rovo%20Dev%20for%20Development%2C%20Testing%2C%20and%20Project%20Management"
format: markdown
---
> Macro (rw-ui-expands-macro)
> 
> > Macro (rw-expand)
> 
> > Macro (toc)

# Introduction

## Overview

In this page, you’ll find a brief overview of Rovo and Rovo Dev (and all its flavours).

Rovo is an Atlassian technology and umbrella that embraces the usage of generative AI to search, act, and automate smartly in the Atlassian ecosystem.

We’ll focus on Rovo Dev, its coding and analysis capabilities, and its integration possibilities with Jira and Xray, to assist the development and Testing team throughout the Software Development Life Cycle.

## Rovo

Rovo is an Atlassian AI platform for enabling smarter work leveraged by AI capabilities.

Rovo is meant not only to support developers but also all other team members, to assist them in obtaining information or to automate tasks.

Rovo can connect with third-party apps outside Atlassian to enhance [Rovo Agents](https://www.atlassian.com/software/rovo/guides/end-user-guide/how-to-use-rovo#rovo-agents), [Rovo Search](https://www.atlassian.com/software/rovo/guides/end-user-guide/how-to-use-rovo#rovo-search), and [Rovo Chat](https://www.atlassian.com/software/rovo/guides/end-user-guide/how-to-use-rovo#rovo-chat). For that, administrators can add/enable [Rovo connectors](https://support.atlassian.com/organization-administration/docs/manage-rovo-connectors/).

Users can also use [Rovo Studio](https://support.atlassian.com/rovo/docs/studio/) to build their own Rovo AI agents that can be used to automate tasks leveraged by AI.

Atlassian also provides Rovo Dev, as we’ll see ahead, which is an AI agent focused on supporting software engineers and development tasks.

> ℹ️ **Rovo vs Rovo Dev**
> ℹ️ 
> ℹ️ - <u>[Rovo](https://www.atlassian.com/software/rovo)</u> enables teams with AI capabilities such as search, chat, and studio apps.
> ℹ️ - [Rovo Dev](https://www.atlassian.com/software/rovo-dev) is an AI agent that expands on Rovo capabilities, specifically designed for professional software engineers. It handles code planning, code generation, code reviews, and automates repetitive work at scale. Rovo Dev has separate <u>[pricing and packaging](https://www.atlassian.com/software/rovo-dev/pricing)</u> from Rovo - Atlassian.


Additionally, skilled users can connect their AI-enabled tools to Atlassian apps using [Atlassian Rovo MCP Server](https://support.atlassian.com/atlassian-rovo-mcp-server/docs/getting-started-with-the-atlassian-remote-mcp-server/) (Figure 1). This way, they can obtain information stored in Jira, for example, process it locally, and, eventually, execute some tasks on Jira based on it.

![Figure 1 - MCP server.png](media://790be915-025f-46c6-b8ac-845ce8b5a342)

## Rovo Dev

[Rovo Dev](https://www.atlassian.com/software/rovo-dev) is an AI agent built by Atlassian for software developers. 

> ℹ️ Rovo Dev is a context-aware AI agent that accelerates the software development lifecycle by handling planning, coding, reviews, and automating repetitive work at scale.

Rovo Dev is available for use directly in the terminal via an extension for the [Atlassian Command Line Interface (ACLI)](https://developer.atlassian.com/cloud/acli/guides/introduction/) tool, or from within IDEs. It’s also available directly within Atlassian products (Jira, Bitbucket) or even on GitHub, to review Pull Requests (PRs), for example.

A few use cases enabled by Rovo Dev:

- Generate code based on Jira Work items and Confluence pages (see [automation capabilities in Jira](https://support.atlassian.com/rovo/docs/work-with-rovo-dev-in-automations/)).
- Code review and acceptance criteria check on pull requests (on GitHub and Bitbucket).

> ℹ️ Rovo Dev credits are different and separate from <u>[Rovo credits](https://support.atlassian.com/rovo/docs/rovo-usage-limits/)</u>:
> ℹ️ 
> ℹ️ - Rovo Dev credits can only be used for <u>[Rovo Dev features](https://support.atlassian.com/rovo/docs/work-with-rovo-dev-agents/)</u> like Rovo Dev CLI, or code reviews.
> ℹ️ - Rovo credits are used for Rovo features like <u>[Rovo Chat](https://support.atlassian.com/rovo/docs/accessing-chat/)</u>, <u>[Rovo agents](https://support.atlassian.com/rovo/docs/agents/)</u>, and <u>[Deep Research](https://support.atlassian.com/rovo/docs/using-rovo-deep-research/)</u>.

### Global Settings

At the organization and site level, it’s possible to enable/disable Rovo Dev for certain clients or on certain apps (Figure 2):

- Bitbucket and GitHub (code reviews).
- CLI.
- VS Code.
- Jira: code generation from Work items.
- Automations: triggers and actions.
- Bitbucket pipelines: summaries and troubleshooting.

![Figure 2 - Settings](media://f2c49651-3ecd-437a-acad-066946649060)

## Rovo Dev CLI

The [Rovo Dev CLI](https://support.atlassian.com/rovo/docs/use-rovo-dev-cli/) is available as an extension for [Atlassian Command Line Interface (ACLI)](https://developer.atlassian.com/cloud/acli/guides/introduction/) (i.e., ACLI tool).  It provides a developer-friendly experience, allowing developers to use Rovo Dev in a TUI (Text User Interface) to:

- Implement, refactor, analyze, and review code.
- Fix bugs.
- Address documentation.

Rovo Dev CLI can interact with:

- Jira, Confluence, Bitbucket.
- Local filesystem.
- Other apps using MCP servers.

# Operations

## Installation and Configuration

> Macro (rw-ui-steps-macro)
> 
> > Macro (rw-step)
> 
> To install Rovo Dev CLI, follow the [official instructions](https://support.atlassian.com/rovo/docs/install-and-run-rovo-dev-cli-on-your-device/).
> 
> > Macro (rw-step)
> 
> The first time, you’ll need to authenticate with Atlassian using a previously created [API token](https://id.atlassian.com/manage-profile/security/api-tokens):
> 
> `acli rovodev auth login`
> 
> > Macro (rw-step)
> 
> Then you can run Rovo Dev within ACLI: `acli rovodev run`


### Skills

Rovo Dev CLI can use [agent skills](https://support.atlassian.com/rovo/docs/extend-rovo-dev-cli-with-agent-skills/). 

These can be installed in a project in `.agents/skills/<skill-name>/`, or at the user-level inside `~/.agents/skills/<skill-name>/`.

The skills used in this tutorial are available in a [GitHub repository](https://github.com/Xray-App/xray-code-snippets). Please consider them as a source of inspiration so you can get some ideas, adapt them to your needs, and use them wisely, at your own risk.

#### Installing Skills

Skills can be installed manually by creating the proper folder and markdown file in your local environment, but they are usually managed using [npx skills](https://github.com/vercel-labs/skills) instead.

**To list available skills:**

```
npx skills add https://github.com/Xray-App/xray-code-snippets --list
```

![Figure 3 - Skills](media://3b80537d-16f9-492b-aec5-f8b2aef1d068)

**To install a specific skill:**

```
npx skills add https://github.com/Xray-App/xray-code-snippets --skill xray-data-extraction
```

Then, in Rovo Dev CLI, we can check the ones that are available using the `/skills` command.

![Figure 4 - Skills .png](media://ca40e85e-8e3a-42e9-b9ea-689e654edec9)

### MCP Servers

CLI users can connect to external MCP servers. This configuration is also used by Rovo Dev within VS Code.

Edit `~/.rovodev/mcp.json` and add your MCP servers. 

In this case, we’re using the [mcp-graphql](https://github.com/blurrah/mcp-graphql) to be able to interact with Xray’s Cloud GraphQL API. 

```
{
    "mcpServers": {
		"mcp-graphql": {
			"type": "stdio",
			"command": "npx",
			"args": [
				"mcp-graphql"
			],
			"env": {
				"ENDPOINT": "https://xray.cloud.getxray.app/api/v2/graphql",
				"ALLOW_MUTATIONS": "true",
				"HEADERS": "{\"Authorization\":\"Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0ZW5hbnQiOiI2NWNkNDhjOC0xYWUzLTNmZTItODQyYy01MzFhMjlhYmExOWUiLCJhY2NvdW50SWQiOiI1NTcwNTg6OTM2NDliNGEtOGIyOC00Yjk2LWJmNzctZWFlYWM5ZDc1MTRmIiwiaXNYZWEiOmZhbHNlLCJpYXQiOjE3NjQ2NzQ2MjQsImV4cCI6MTc2NDc2MTAyNCwiYXVkIjoiMjE1RkZENjlGRTQ2NDQ3MjhDNzIxODJFMDVEQUNBNDkiLCJpc3MiOiJjb20ueHBhbmRpdC5wbHVnaW5zLnhyYXkiLCJzdWIiOiIyMTVGRkQ2OUZFNDY0NDcyOEM3MjE4MkUwNURBQ0E0OSJ9.JSK7jA_Pw9L8-_sWMcHgx0zHZAwd3_f7_Gzucxpduxo\"}",
				"PATH": "/Users/xpto/.nvm/versions/node/v22.12.0/bin:/bin"
			}
		}
    }
}
```

 

This requires that we have obtained the [Xray API](https://getxraydocs.atlassian.net/wiki/spaces/XRAYCLOUD/pages/44565892) authentication elsewhere. As an example, right from your shell/terminal.

```shell
curl -H "Content-Type: application/json" -X POST --data '{ "client_id": "32A27E69B0AC4E539C14010000000000","client_secret": "d62f81eb9ed859e11e54356dd8a00e4a5f0d0c2a2b52340776f6c70000000000" }'  https://xray.cloud.getxray.app/api/v2/authenticate
```

## Examples

### Implementation of Features / User Stories

The following scenario depicts the implementation of a user story defined in Jira; in this example, we’re trying to add the ability to update users through the REST API.

```
implement ST-233
```

![Figure 5 - Implementation.png](media://b59d57c3-3f5a-4507-a330-cbdfa94f6794)

### Bugs and Bug Fixing

Rovo Dev can be used to analyze the code and find bugs, and, leveraged by the connection to Jira, report them as Bug Work items.

```
analyze code to find bugs; enumerate them, with a inline summary, description, and priority (Low, Medium, High, Highest). Create Bug issues for this on project ST and make sure they have the AI label.
```

![Figure 6 - Bugs](media://a621bd46-bedc-4a7b-8e72-219182d2c0c6)

Based on a previously reported bug, we can use Rovo Dev to implement (or suggest) a fix for it.

```
fix bug ST-248
```


```
...
│ Security Features Added:                                                                                             │
│                                                                                                                      │
│  • 🔐 BCrypt password hashing                                                                                        │
│  • 🛡️ Password strength validation                                                                                    │
│  • 🚫 Plaintext password prevention                                                                                  │
│  • 🔒 API response protection                                                                                        │
│  • ✅ Secure user creation workflow                                                                                  │
│  • 🧪 Comprehensive security testing  
```

![Figure 7 - Activity](media://f7b5203c-011e-45bc-a861-7cb06b2fed3e)

### Analysis

In the following examples, we’ll see two use cases where Rovo Dev can be used to analyze both the code and the historical test results data.

The first use case shows how we can use Rovo Dev to analyze the code and compare against it a previously reported Bug in Jira.

```
As an experienced software engineer with deep expertise on security, analyze current code and see if ST-248 has been properly addressed    
```


> ℹ️ The following output shows the CLI output considering a hypothetical scenario, just for demo purposes, where the actual fix was not made. Or it’s not on the checked out branch, therefore it highlights this inconsistency between what’s documented vs what's really implemented.

![Figure 8 - Output.png](media://409c8993-2148-4a7f-9d25-26c38c6572c9)

In this use case, our aim is to identify the most flaky Tests based on the related Test Runs. This would be mostly relevant for automated Tests as a way to depict problems with those Tests (or the features they verify).

```
looking at project ST, which tests are the most flaky? Look at previous 10 test runs for these tests using the mcp-graphql tool for the Xray Cloud instance. For flakiness metric, consider the transition rate. Consider as failures all non-pass results. 
```

![Figure 9 - Output.png](media://4a897c27-a4f5-488c-9ee1-1a9ec0370490)

### Documentation

Lets say we aim to create a detailed documentation page in Confluence, concerning a specific implementation that we think might be relevant to document and share with the team (Figure 10 and 11).

```
Create documentation as a Confluence page for the previous security implementation, on https://xraytutorials.atlassian.net instance█                        
```

![Figure 10 - Documentation](media://fff06cbd-c770-49de-8361-405166a36f7b)

![Figure 11 - Documentation](media://ed180612-5520-463b-a531-0ea3a15f9d03)

### Project Management

In this use case, we aim to assess if the items being worked on within the sprint are ready to be shipped (Figure 12).

```
Are my sprint items from project ST ready based on the current test coverage?
```

![Figure 12 - Items.png](media://ec750ae1-be8d-459a-a564-1f2de06dfeab)

We can tailor the prompt a bit to enforce analysis of requirement coverage using the skills we have. 

```
Are my sprint items from project ST ready based on the current test coverage? use the skill for overall requirement
coverage
```

This is a curious case, as we can see Rovo Dev combining different sources of information: coverage from Xray and Testing results, the actual code, what is described on the Work items - and the same inconsistencies may arise from that.

![Figure 13 - Coverage](media://357a8fa8-5fcc-474f-9644-b16bae12770e)

### Unsorted Prompt Examples

Next, you can find examples of prompts focused on Test design.

```
create an automated test based on the existing manual one ST-253. Use mcp-graphql tool to get the details of that test.
```

```
create 2 manual tests for the user story ST-1, covering the happy path. use mcp-graphql to create the manual tests with the respective steps.
```

```
implement an automated test considering the steps of the manual test identified by the issue key ST-306 in Jira. That test is a Xray test, so use the proper MCP to get information.
```


You could also use Rovo Dev to assist with [Test planning](https://getxraydocs.atlassian.net/wiki/spaces/XRAYCLOUD/pages/44565044).

```
generate a Test Plan for the tests currently failing that cover user story ST-1  
```

# Rovo Dev in VS Code

[Atlassian provides an extension](https://marketplace.visualstudio.com/items?itemName=Atlassian.atlascode) to interact with Jira, Bitbucket, and Rovo Dev.

Rovo Dev in VS Code can be used to answer questions about the code repository or to implement Work items, based on information provided by the user or stored in Jira artifacts, as detailed on the initial [announcement in Atlassian Community](https://community.atlassian.com/forums/Rovo-for-Software-Teams-Beta/Rovo-Dev-is-available-in-your-VSCode/ba-p/3158426). This extension is an alternative to using the Rovo Dev CLI TUI.

![Figure 14 - Rovo Dev](media://14e86083-7af3-486c-947d-22eb72dbe976)

Rovo Dev in VS Code provides three chat modes:

- *Default*: with full capabilities (read, write, execute).
- *Ask*: to just ask questions (read-only).
- *Plan*:  to obtain a detailed plan based on a prompt, before implementation is performed.

## Installation and Configuration

Install [this extension](https://marketplace.visualstudio.com/items?itemName=Atlassian.atlascode) as any other extension in VS Code, from the [marketplace](https://marketplace.visualstudio.com/items?itemName=Atlassian.atlascode) or from the Extensions side tab within VS Code.

There are two settings: *Settings* and *Extension Settings (UI)* (Figure 15 - 1; 2).

![Figure 15 - Settings.png](media://8e53f357-ddd6-4c1c-afd4-1f4f60e2dcb6)

General configurations are available in *Settings* (Figure 15 - 2):

- They can be used to enable or disable Rovo Dev Agentic AI, for example.
- They are enabled by default (Figure 16 - 1).

![Figure 16 - Settings](media://c614bcdd-0517-4968-84ce-ee9927d3f369)


The *Extension Settings (UI)* panel (Figure 17) can be used to configure access to the Atlassian platform and its apps, like Jira. 

![Figure 17 - Settings](media://6bbd0b21-00b2-4634-9f4d-37cba4489292)

> ⚠️ Make sure to authenticate with your Jira instance (mandatory; Figure 18).

![Figure 18 - Authentication](media://ab365e38-78ee-45a5-8132-a29ed374a44d)

### MCP Servers

Rovo Dev in VS Code can connect to external MCP servers. 

It uses the same configuration as Rovo Dev CLI, so edit and review `~/.rovodev/mcp.json`. 

> ℹ️ Please see the Rovo Dev CLI section below for an example showcasing the integration with Xray.

## Examples

### Obtaining Information on Manual Test in Xray

Consider a hypothetical scenario where we aim to get information about a given manual Test in Xray and its steps data (action, data, expected result).

```
get manual test steps from Test issue ST-306; use the mcp-graphql MCP server
```

![Figure 19 - Information](media://5dd3ba4c-2e7c-498b-ae16-99e36656a049)

# References

- [https://www.atlassian.com/software/rovo/guides/end-user-guide/what-is-rovo](https://www.atlassian.com/software/rovo/guides/end-user-guide/what-is-rovo)
- [https://support.atlassian.com/rovo/docs/work-with-rovo-dev-in-the-ide/](https://support.atlassian.com/rovo/docs/work-with-rovo-dev-in-the-ide/)
- [https://support.atlassian.com/rovo/docs/connect-to-an-mcp-server-in-rovo-dev-cli/](https://support.atlassian.com/rovo/docs/connect-to-an-mcp-server-in-rovo-dev-cli/)
- [Rovo Dev](https://www.atlassian.com/software/rovo-dev)
  - [https://www.youtube.com/watch?v=tEbCO3wG_vQ](https://www.youtube.com/watch?v=tEbCO3wG_vQ)
  - [https://support.atlassian.com/rovo/docs/work-with-rovo-dev-agents/](https://support.atlassian.com/rovo/docs/work-with-rovo-dev-agents/)
  - [https://support.atlassian.com/rovo/docs/turn-rovo-dev-features-on-and-off/](https://support.atlassian.com/rovo/docs/turn-rovo-dev-features-on-and-off/)
  - [https://support.atlassian.com/rovo/docs/view-your-rovo-dev-credit-usage/](https://support.atlassian.com/rovo/docs/view-your-rovo-dev-credit-usage/)
  - [https://www.youtube.com/watch?v=gGUq6fAmFNo](https://www.youtube.com/watch?v=gGUq6fAmFNo)
  - [https://support.atlassian.com/rovo/docs/check-acceptance-criteria-in-a-code-review/](https://support.atlassian.com/rovo/docs/check-acceptance-criteria-in-a-code-review/)
- [Rovo Dev CLI](https://support.atlassian.com/rovo/docs/use-rovo-dev-cli/)


> Macro (rw-ui-expands-macro)
> 
> > Macro (rw-expand)
> 
> If you have questions or technical issues, please [contact the Support team via the Customer Portal (Jira service management)](https://jira.getxray.app/servicedesk/customer/portal/2/user/login?destination=portal%2F2%2Fcreate%2F28) or [send us a message using the in-app chat](https://getxraydocs.atlassian.net/wiki/spaces/XRAYCLOUD/pages/44577312).