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:
“You have access to this discussion context . Summarize the main options we explored, key trade-offs, and any unresolved questions. Focus on effort, scale, and user experience as the main dimensions of comparison in a format similar to “.
“Take this and as input and draft a high-level proposal in the style of . Define the purpose, problem statement, goals, non-goals, proposed solution overview. Also capture risks and open questions. Stay high-level and avoid deep implementation details.”
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:
- Open the relevant repositories in VS Code
- Point Rovo Dev at:
- The key sections of the RFC (requirements, constraints, non‑goals)
- 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
“Using this as the high-level requirement and this codebase as context, propose detailed APIs, data models, and integration points. Ensure your suggestions align with existing patterns in the repository and fit the overall solution described in the RFC.”
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
“From this propose a Jira breakdown into Epics contained detailed child Work Items. Group by service and integration boundary. Include relevant snippets and clear acceptance criteria.”
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
“Referencing this , generate an implementation plan for this repository only. Prioritize the minimal path to a working end‑to‑end slice.”
“Build the next step in this implementation plan, following current patterns, and validating it with proper test coverage.”
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