Using Rovo Dev in VS Code for Architecting Solutions

When we intend to roll out a new software solution that would impact multiple teams, before implementation can start, we need to get overall alignment from all involved parties, and then detail the chosen architectural approach.

Every single one of these steps can be challenging – but we have found ways to speed up every one of them with the artificial intelligence tools at our disposal.

1. From conversation to high-level plan in minutes

When floating new ideas, it all starts with a conversation – a Loom recording, a Slack thread, or meeting notes in Confluence. Then we use Rovo Dev to:

• Extract the main options, trade‑offs and assumptions from the discussion
• Organize them around key decision factors (for example: effort, scale and user experience)
• Draft a concise high‑level proposal in the style of our preferred decision templates

Use prompts like:

By the time we open VS Code, we already have an aligned decision record and a lightweight architectural outline.

2. Let Rovo Dev draft the detailed architecture and implementation plan

Once we have a high-level decision capture, we start drafting the architectural details. Here’s how Rovo Dev in VS Code help us here:

1. Open the relevant repositories in VS Code
2. Point Rovo Dev at:
   1. The key sections of the RFC (requirements, constraints, non‑goals)
   2. The folders or services that will be impacted

We then delegate specific design areas such as:

• API contracts (request/response shapes, versioning, error handling)
• Data flows and sequence of calls across services
• Integration points with existing systems
• Non‑functional constraints (latency, reliability, standards, observability)
• Edge‑case handling and error modes

Rovo Dev proposes here designs and code snippets that reference the actual repo, building a detailed architectural and implementation plan that we can then review with domain experts before diving into the implementation phase.

3. Feed this document to Rovo Dev for implementation

With the detailed architecture in place, Rovo Dev can execute the implementation inside VS Code.

3.1 Turn architecture into a delivery plan

For larger initiatives, we use the plan to generate concrete work:

• Break the architecture into Epics and Work Items in Jira
• Map each architectural component (service, endpoint, data pipeline) to one or more tasks
• Capture technical risks and spikes as separate items

3.2 Implement incrementally with Rovo Dev inside of VS Code

Once there’s a detailed work breakdown (or for changes of smaller scope), we let Rovo Dev take charge of the implementation step-by-step:

• Generate modules consistent with existing patterns
• Update the modules that match the proposed design
• Implement one feature at a time, following the RFC
• Validate changes generating proper test cases

Conclusions

This development flow complements how we already use Atlassian tools, from decision making to implementation, adding Rovo Dev as an orchestration layer that connects discussions, specs, and code.

• Confluence, Slack and Loom capture the initial exploration and alignment
• Rovo Dev turns that into structured decision records and high‑level architecture
• Jira reflects the architecture as executable work, staying connected to both decisions and implementation
• Rovo Dev in VS Code uses those documents plus the actual repositories to propose detailed designs and code