Rovo Dev CLI is Atlassian's AI-powered development agent that runs in your terminal, where it can suggest tests, refactor code, troubleshoot build errors and connect to Jira issues and Confluence docs. Currently in beta, it is launched with a command like acli rovodev run from your project directory, so the agent can read your codebase.
In software development, every second counts. Imagine if your command-line interface (CLI) could double as an AI coding partner, assisting with everything from writing tests to fixing bugs all without leaving your terminal. This isn’t science fiction; it’s now possible with Atlassian’s Rovo Dev CLI. Introduced as part of Atlassian’s Rovo AI suite, Rovo Dev CLI is an intelligent agent that lives in your terminal and helps developers code smarter and faster right in the shell environment. In this blog post, we’ll dive into how integrating AI into the developer CLI works and what the “Use Rovo Dev Agents in Your CLI” feature means for you. We’ll explore how you can get test suggestions, perform automated refactoring, troubleshoot build errors, and even connect to Jira issues or Confluence docs all from the command line. For tech-savvy teams looking to boost productivity without constantly switching tools, this might just be a game-changer.
Rovo Dev CLI is Atlassian’s AI-powered development agent that runs directly in your command-line interface. It transforms a traditional terminal session into a smart collaborator that understands natural language, writes and reviews code, and connects with your existing development tools. Developers often spend a lot of time in the terminal navigating code, running tests, pushing commits and Rovo Dev CLI aims to make that experience more efficient. By integrating AI into the CLI, Atlassian is essentially bringing a conversational coding assistant into the developer’s most familiar environment.
This means you can ask the CLI to handle various coding tasks as if you were chatting with a teammate. The agent has deep knowledge of your codebase (it can read your repository) and awareness of your Atlassian environment. For example, if you’re not sure how a part of the code works, you can ask in plain English and get an explanation instantly. If you need to generate a piece of code or documentation, the AI can do that on the fly. All of this happens without switching windows or opening a web browser. The goal is to reduce friction and keep you “in the zone” by letting the AI handle routine tasks and complex analysis directly within the terminal.
By bringing AI directly into the CLI, developers can maintain their flow state. There’s no need to alt-tab between the terminal, IDE, browser, and documentation Rovo Dev CLI integrates all these capabilities in one place. It’s like having a pair programmer who never sleeps, ready to help with code or answer questions at any moment. This innovation is especially powerful for enterprise teams using Atlassian’s ecosystem, because it’s built to seamlessly integrate with Jira for issue tracking and Confluence for documentation. In the following sections, we’ll look at how to get started with Rovo Dev CLI and then break down its key features with practical examples.
To turn your terminal into an AI coding partner, you first need to set up Rovo Dev CLI in your development environment. Here’s a quick how-to for getting started:
Install the Atlassian CLI and Rovo Dev: Rovo Dev CLI is part of Atlassian’s toolset, currently in beta. Begin by installing the Atlassian Command Line Interface (ACLI) and the Rovo Dev CLI tool on your device. Atlassian provides a download and installation guide typically it involves running a package installer or a command like npm or a binary, depending on your system.
Activate Rovo Dev for Your Team: Ensure that Rovo Dev CLI is enabled for your Atlassian site or project. An administrator might need to activate the Rovo Dev Agent feature in your Atlassian cloud settings, since it’s a new feature. Once enabled, the AI agent can connect to your Atlassian cloud products with the right permissions.
Authenticate and Log In: After installation, you’ll likely authenticate with your Atlassian credentials so that Rovo Dev can access your code repositories and Atlassian projects. The CLI will prompt you to log in or open a browser to authorize access to your Jira issues, Confluence spaces, and source code.
Run Rovo Dev in the Terminal: Launch the interactive AI session by running the appropriate CLI command. In this case, you would run something like acli rovodev run in your terminal. This command starts an interactive mode where the AI agent is listening for your instructions. You’ll see a prompt (for example, a > or special indicator) signaling that Rovo Dev is ready for queries.
Begin with a Small Task: Once Rovo Dev CLI is running, test it out by asking a simple question or task. For instance, you could type a natural language prompt like “Explain what this repository does” or “List my open Jira issues”. The agent should respond with answers or take actions based on your request. This confirms everything is set up correctly.
Use Slash Commands and Modes: While interacting, remember that Rovo Dev CLI offers special commands. Typing / in the session may show options like switching sessions or clearing history. Rovo Dev can operate in two modes: interactive and non-interactive. Interactive mode lets you have a back-and-forth chat refining the task, whereas non-interactive mode can execute a single instruction immediately (for example, you can run a one-liner command to apply a code change without the back-and-forth). Start with interactive mode to get comfortable.
Context: Navigate to Your Project Directory: Make sure you’re running the CLI in the context of your project’s directory so that the AI can read your codebase. Rovo Dev will analyze the files around to provide relevant answers. For example, if you want it to generate tests for your project, it needs to see your source code files. So cd into the repository folder before running the agent.
Stay Safe and Monitor Outputs: As with any AI tool, review the changes or suggestions it provides before applying them. Rovo Dev CLI can write code and even modify files, so it’s good practice to use version control (like Git) and commit changes in steps. This way, you can always revert if something doesn’t look right. Think of the AI as an assistant you’re still the pilot in charge.
Once set up, you’re ready to leverage Rovo Dev CLI’s capabilities. Now, let’s explore those key capabilities one by one and see how this AI agent can transform your daily development tasks.
One of the most exciting features of integrating AI into your CLI is the ability to generate and suggest tests automatically. Writing unit tests and integration tests can be tedious, but they’re crucial for maintaining software quality. With Rovo Dev CLI acting as your AI assistant, you can quickly get test code suggestions without leaving the terminal. Imagine you’ve just written a new function and you want to create a unit test for it. Instead of manually writing the test from scratch, you can simply ask your CLI agent to help. For example, in the Rovo Dev interactive prompt you might type: “Create a unit test for the new UserService class that covers the registerUser method.” The AI will analyze the UserService code in your repository and generate a test case, complete with setup, execution, and assertions. It might output a block of code in your terminal that you can review. This not only saves time but also ensures you don’t forget edge cases the AI might even suggest testing scenarios you hadn’t considered.
The test suggestions aren’t limited to one function. You could ask for broader assistance, like “Generate tests for all functions in this module” or even use the CLI’s non-interactive mode to apply a batch of tests at once. For example, running a command like acli rovodev run "Create unit tests for all components without tests" would instruct the agent to automatically create test files for any components lacking coverage. The AI leverages knowledge of common testing patterns and frameworks. If you’re using Jest for JavaScript or JUnit for Java, the generated tests will likely follow those familiar formats. Because Rovo Dev CLI works within your project context, it can reference actual classes and functions in your codebase when generating tests. This means the suggestions are not generic boilerplate, but tailored to your code. If a function is supposed to throw an error under certain conditions, the AI-written test will probably include that scenario. If your code uses specific libraries or frameworks, the tests will incorporate those. Essentially, your AI partner helps enforce best practices like test-driven development (TDD) by making it almost effortless to get started on tests.
Another advantage is speed. Instead of spending an hour writing a suite of tests, you can have a first draft generated in seconds. You, as the developer, can then review and refine the suggested tests. Treat the AI’s output as a starting point perhaps you’ll add a couple more assertions or tweak the test data. The AI might even catch things you missed. It’s like having a QA-minded assistant sitting next to you, pointing out, “Don’t forget to test what happens if the input is null,” all via the CLI. By embracing AI-powered test generation, teams can achieve higher test coverage with less manual grunt work. The result is more robust code and faster development cycles, since catching bugs early through good tests saves time down the line. And the best part: you did it all right from your terminal window, staying in your flow.
Beyond testing, Rovo Dev CLI shines when it comes to refactoring and improving your code. Refactoring is often about making code cleaner, faster, or more maintainable without changing its functionality. It’s a task developers know they should do regularly, but it can be hard to find time or know where to start. Your AI agent can act like a vigilant pair of eyes, suggesting enhancements on the fly. Here are some ways you can use the AI for refactoring and code review:
Identify Code Smells and Improvements: You can prompt Rovo Dev with something like “Review this repository and suggest improvements for readability and performance.” The AI will scan through your code and point out potential refactoring opportunities. For example, it might find a function that is too long or complex and suggest breaking it into smaller functions. Or it could spot duplicate code blocks that could be consolidated. These suggestions appear right in the terminal, so you can quickly navigate to the relevant files and make changes.
Automated Refactoring Suggestions: Let’s say you have a block of code that works but isn’t efficient. You could copy-paste it into the Rovo CLI (or refer to it by function name if the agent has indexed your code) and ask, “Can you refactor this function to improve its efficiency?” The AI might then output a revised version of the function with cleaner logic or better use of language features. For instance, it might replace a cumbersome loop with a more elegant functional approach, or apply a design pattern to simplify logic.
Apply Changes with Confirmation: The AI not only suggests code changes, but can also help apply them. You can take a suggestion and tell Rovo Dev CLI to implement it. For example, if it suggests renaming a variable for clarity or extracting a method, you can instruct it to go ahead and make that change across the codebase. It will modify the files accordingly. Of course, it’s wise to review the diff (difference) which you can also ask the AI to show or explain before committing the changes. This way, you maintain control over your code.
Interactive Code Reviews: Think of Rovo Dev as a tireless code reviewer. After you write new code, you can ask it, “Analyze this code for any potential issues or improvements.” It might highlight things like missing error handling, inefficient algorithms, or stylistic inconsistencies with the rest of your project. This feedback loop helps you clean up code before it goes into a pull request for your team. It’s like having an on-demand reviewer who catches issues early.
Learn Best Practices in Real-Time: When the AI suggests a refactor, it often follows best practices. This provides a learning opportunity for developers. For example, the agent might transform a messy concatenation into a cleaner template string, or suggest using built-in functions instead of reinventing the wheel. Over time, by following these suggestions, your whole team can learn to write cleaner code initially. The CLI agent essentially brings the knowledge of countless style guides and performance tips right to your fingertips.
Stay in the Flow: Perhaps the biggest benefit is that all of this happens without leaving your development flow. If you’ve ever broken concentration to search online for “How to optimize this code” or to run a linter separately, you know it disrupts your momentum. With Rovo Dev CLI, the answers come to you in the terminal. You might even integrate it into your git workflow for example, before committing code, quickly ask Rovo if there’s anything you should improve. It’s a seamless way to maintain high code quality continuously.
By using an AI assistant for refactoring, teams can gradually improve their codebases and reduce technical debt, one suggestion at a time. It’s efficient, educational, and integrated making the process of polishing code much less daunting.
Every developer knows the sinking feeling of a build failing or a mysterious bug popping up. Traditionally, troubleshooting involves digging through logs, searching error messages on Stack Overflow, and lots of trial and error. With an AI integrated into your CLI, that process becomes a lot more streamlined. Rovo Dev CLI can act as a first-responder to your build failures and runtime errors, helping you diagnose and fix issues faster again, all from the comfort of your terminal. Let’s consider a scenario: you run your continuous integration (CI) pipeline or a local build, and it fails with an error. Normally, you’d scroll through the error log trying to pinpoint the cause. Now, you can copy that error output and ask Rovo Dev CLI, “What went wrong in this build and how can I fix it?” The AI will parse the log or error message and give you a human-readable explanation. For example, if there’s a null pointer exception in a specific module, the AI might explain which line caused it and why. If a test case failed, Rovo Dev can summarize which test failed and the likely reason.
Not only does the AI explain problems, it can often suggest solutions on the spot. Suppose your build failed because of a missing dependency or a version mismatch in your project configuration. The CLI assistant could detect that and say: “It looks like library X is not installed or listed properly. Adding it to your package configuration might resolve the issue.” In many cases, it might even offer to make the fix for instance, by updating a build file or adding the missing import in code. You remain in control by reviewing the suggestion, but the heavy lifting of pinpointing the issue is handled for you. Debugging runtime errors gets easier too. If your application threw a 500 server error, you can ask Rovo Dev to investigate. An example prompt could be: “I’m getting a 500 error when fetching data from the API. Find the issue and fix it.” Because Rovo Dev CLI has read your codebase, it might trace through the code path that handles that API call and identify where things went wrong. It could respond with something like: “The error originates from DataService.fetchData() because it’s not handling the case where the API returns null. I suggest adding a null check and default value there.” It might then show you a patch of code with the fix implemented.
Another powerful aspect is troubleshooting CI/CD pipelines. Rovo Dev can analyze your pipeline logs very quickly. If a deployment pipeline fails, the AI can highlight the exact step. It can even suggest how to resolve it, such as increasing a timeout, updating a configuration, or addressing the underlying code issue. This kind of quick analysis means less time combing through logs and more time applying the fix. Throughout the debugging process, you’re conversing with the CLI as you would with a team mentor or senior engineer. You can ask follow-up questions too: “Why would that library be missing? Did I forget to commit something?” and the AI can contextualize its answers based on project history or common patterns. The interplay feels natural you describe the problem in plain language, and the AI provides insights and solutions. Crucially, all these diagnostics happen in real time. The moment you see a failure, your AI partner is ready to help interpret it. This reduces downtime significantly. Instead of losing an afternoon on a vexing bug, you might resolve it in minutes with the AI’s guidance. It’s like having a debugger, search engine, and advisor all rolled into one, right in your terminal window. By making troubleshooting more efficient, Rovo Dev CLI helps teams maintain confidence in deploying and updating software. Fewer delays due to unexpected bugs means smoother releases. And developers gain a deeper understanding of their systems, because the AI often educates as it explains, shedding light on how and why things went wrong.
Modern software development isn’t just about writing code it’s also about managing tasks and documentation. Typically, developers have to switch between their coding environment and tools like Jira or Confluence. Rovo Dev CLI eliminates this context switching by connecting your terminal directly to Jira and Confluence. Here are some of the powerful ways this integration manifests:
View and Manage Jira Issues: You can query Jira from your terminal using natural language. For example: “Which Jira issues are assigned to me and still open?” The AI will fetch the list of your Jira work items and display them right in the CLI. Each item might show the issue key, title, and status. This means while you’re in the middle of coding, you can quickly check what’s on your plate or update an issue without opening the Jira web interface.
Implement Code Directly for a Jira Ticket: Rovo Dev CLI can use the context of a Jira issue to help you code. Let’s say you have a user story “Add dark mode to the application” tracked as PROJ-456 in Jira. You could tell the agent: “Implement code changes for Jira issue PROJ-456.” The AI will reach out to get the details of that ticket for instance, the acceptance criteria or any description of the feature. Then, it can guide you through implementing that feature step by step. It might generate a to-do list or even starter code. Essentially, the AI bridges the requirement (from Jira) to the code changes needed, all in one continuous workflow.
Update Jira Without Leaving Terminal: After completing a task, you usually would go to Jira, find the issue, and change its status or add a comment. With Rovo Dev, you can do this in-line. For example, you might say: “Mark Jira issue PROJ-456 as done and leave a comment saying the feature is implemented in commit abc123.” The CLI agent can execute that, moving the issue to Done and posting the comment with the commit ID. This ensures your project management is up to date, without breaking your focus to navigate Jira manually.
Search and Retrieve Confluence Documentation: Need to recall a design decision or an API spec documented in Confluence? Just ask the CLI. You could prompt: “Find the Confluence page that details the authentication microservice design.” If your Confluence space has a page on that, the AI can search and return the relevant content or at least a summary with a link. It’s like having the company wiki at your fingertips in the terminal. This is extremely useful when you want to confirm something from docs without losing your coding flow.
Publish Documentation to Confluence: After coding a new feature, documentation is often an afterthought because it’s cumbersome to switch to Confluence and write it. With Rovo Dev CLI, you can draft and publish docs right from the CLI. For example: “Create a page in Confluence titled ‘Release Notes v2.0’ and include the list of new features and how to enable them.” The AI can take what it knows and create a nicely formatted Confluence page in the specified space. You might also use it to update existing documentation: “Update the Confluence page ‘API Endpoints’ with the new endpoint for user settings.” The agent will edit that page accordingly.
Seamless Bitbucket/Git Integration: While not mentioned explicitly in our earlier points, it’s worth noting that integration extends to code repositories too. If you use Bitbucket, Rovo Dev can tie everything together from mentioning issue keys in commit messages to creating pull requests. For instance, it could draft a pull request description summarizing your changes and even link the Jira issue automatically, all through a prompt like “Open a pull request for issue PROJ-456 with reviewers John and Jane.”
No More Context-Switching: The overarching benefit of all these integrations is the removal of context-switching. A developer can stay in one terminal window and accomplish what used to require three different browser tabs and applications. This tight coupling between coding, tracking, and documenting means fewer mental shifts and less time lost. The CLI becomes a hub for both development and collaboration.
With Jira and Confluence in the mix, Rovo Dev CLI truly empowers developers to go from idea to implementation to documentation in one continuous flow. It’s a glimpse into a future where your tools don’t feel like separate silos, but rather extensions of your natural workflow. For teams already using Atlassian’s ecosystem, this can significantly boost efficiency and ensure that nothing falls through the cracks.
Integrating AI into the developer CLI is not just a novelty it’s a practical enhancement that stands to change the way we write and ship software. Atlassian’s Rovo Dev CLI brings the power of generative AI directly into the tools developers use every day, enabling smarter coding, faster debugging, and seamless integration with project management and documentation. By turning your terminal into an AI-powered coding partner, you can automate tedious tasks, get intelligent suggestions on demand, and keep your focus on solving the high-value problems. Early adopters of Rovo Dev CLI are finding that it boosts productivity and developer happiness. Tedious chores like writing boilerplate tests or combing through error logs become quicker and even educational with the AI’s help. Teams can maintain momentum during sprints because less time is spent context-switching between coding, testing, and updating tickets. And because the AI agent is deeply integrated with Atlassian tools, it fits naturally into existing workflows whether you’re a solo developer or part of a large enterprise team. As Atlassian Solution Partners, we at Atlas Bench are excited about what Rovo Dev Agents can do for development teams. Embracing this AI-driven approach in your CLI could be a significant step toward streamlining your software delivery pipeline and staying ahead in the era of AI-augmented development. The future of coding is here, and it’s conversational, collaborative, and incredibly powerful.