As software teams explore AI-assisted coding, a new approach has emerged to get better results: Spec Driven Development. This approach, often abbreviated SDD, shifts the interaction with AI coding tools from ad hoc prompts to a more structured, plan-driven workflow. Atlassian’s own AI coding assistant, Rovo Dev, provides a perfect example of how SDD can improve coding outcomes. In this blog, we at Atlas Bench an Atlassian Platinum Solution Partner break down what SDD is, why it’s more effective than casual "vibe coding," and how you can apply it to collaborate with AI agents for better code. We’ll highlight key principles, share a simple analogy, and walk through a real example using Rovo Dev. By the end, you’ll see how clear specifications and iterative planning can transform your development process and reduce costly rework.
Modern AI coding tools can certainly speed up development, but relying on a quick one-off prompt can lead to problems. Here are the common pitfalls of this free-form approach:
Lack of Context: With a vague request, the AI has to guess what you really need. Important details get missed if they aren’t explicitly provided up front. The agent might produce code that looks good but solves the wrong problem.
Assumptions and Rework: One-shot prompts often result in polished output that doesn’t meet the actual requirements. Since the AI wasn’t given full context or guardrails, you end up discovering mistakes later and spending time reworking or scrapping that code.
No Memory of Decisions: As complexity grows, a single prompt approach breaks down. The AI can contradict earlier decisions or forget important context from earlier in the conversation. There are no checkpoints to keep it on track.
Transient and Ad Hoc: Vibe coding sessions are stateless and unstructured. You throw a prompt, get an answer, and hope it’s right. There’s no durable plan or documentation for what was asked or why decisions were made, making it hard to review or collaborate on the result.
In short, improvising with one-shot prompts may work for trivial tasks, but it quickly falls apart on larger projects. Without a clear plan, the AI agent is just guessing. This often leads to technical debt, misunderstandings, and wasted effort.
Spec-Driven Development is a more deliberate process where you plan, review, and iterate before writing the actual code. Instead of jumping straight into coding with an AI, you collaborate with the AI to produce a detailed specification or plan first. This spec becomes a living blueprint and a single source of truth that guides all coding steps. With SDD, you shift from ad hoc prompting to a structured collaboration between human and AI. The workflow typically looks like this: you give the AI an initial request along with any relevant guidelines or context, the AI responds with a proposed plan, you review and refine that plan, and only then do you allow the AI to execute each step. By catching misunderstandings or wrong assumptions in the planning stage, you prevent them from propagating into the code. It’s similar to traditional software planning in that errors caught earlier result in much less damage than errors caught after code is written. In essence, SDD makes the specification the core artifact. The spec isn’t a static document shelved away; it’s actionable and drives the coding process. The development agent uses this spec to understand exactly what to do, step by step. This approach ensures that the AI’s output aligns with the project’s real requirements and the team’s standards before any commit is made.
To understand the impact of SDD, let’s contrast it with the loose “vibe coding” approach:
Upfront Guardrails vs. Open-Ended Prompts: SDD starts by setting firm guidelines and context for the AI. Instead of an open-ended “do X” prompt, you provide constraints and standards from the start. This might include coding standards, design requirements, or domain context that the AI must adhere to. Vibe coding, on the other hand, provides minimal guidance and hopes the AI fills in the gaps.
Iterative Planning vs. Single Shot: In SDD, the AI breaks a large request into multiple smaller steps and presents a plan. You have multiple opportunities to review and course-correct. Each step is verified before moving on. With a one-shot approach, you get a single answer; if that’s off-base, the only option is to start over.
Small, Focused Changes vs. Big Bang Output: SDD encourages making changes in small, logical increments that can be tested or reviewed in isolation. The agent might plan to modify one module at a time or add one feature at a time, rather than dumping a huge code change all at once. This isolation makes it easier to spot issues. Vibe coding often delivers a big blob of code changes that are harder to parse and validate in one go.
Persistent Knowledge vs. Forgetfulness: Because SDD uses a spec as the source of truth, the context is preserved throughout the process. The AI and the human refer back to the same spec at each step, so nothing important gets lost. In contrast, a one-off prompt can lead to the AI forgetting earlier context or decisions, since there’s no persistent plan it’s following.
Clarity and Justification: Each step in SDD comes with an explanation of what the AI plans to do and why. This means you see the reasoning or design behind the code before it’s written. In vibe coding, you often only see the final code and have to infer why the AI chose that approach.
By making these changes to how you work with AI, Spec-Driven Development significantly reduces misfires. You and the AI agent stay aligned on the what and the why at every phase of the task.
To illustrate the difference, imagine a simple analogy from construction. Say you tell a builder, “Build me a building!” and nothing more. If the builder has no further context, you might end up with a generic house when in fact you needed a hospital, or perhaps they start erecting a literal brick building when you actually wanted a miniature model for a presentation. This is essentially what happens with naive one-shot prompts, the AI fills in the blanks on its own, often incorrectly. Now imagine instead you approach an architect and say: “We need a building for a city hospital, here are the requirements and constraints.” The architect will use building codes, best practices, and clarifying questions to draw up blueprints. There will be a detailed plan, reviews at each stage, and checks against those initial requirements. Only after the plan is agreed upon do the builders break ground. This structured approach is what Spec-Driven Development brings to the table for AI-driven coding.
In the context of AI development, you act like the architect or project manager providing clear requirements and guardrails. Those guardrails might include coding standards, security policies, performance criteria, and any other constraints the solution must obey. Many teams formalize these in a shared instruction file. This is analogous to providing the “engineering handbook” to your AI, a common set of rules it should follow on every project. With the requirements and guidelines in place, you then ask the AI to propose a plan. The AI becomes like your junior architect: it drafts a step-by-step plan to implement the solution. Crucially, SDD involves back-and-forth dialogue at this stage. The AI might come back with a plan, and you review it carefully before any code is written. If something is unclear or off target, you clarify or adjust the spec and ask the AI to update the plan. This iterative planning continues until you’re confident the plan covers the right solution.
Only then do you green-light the execution. The AI will carry out the plan step by step: writing code for Step 1, then pausing for you to review before moving to Step 2. You act as the reviewer at each checkpoint, verifying the output or making tweaks to the plan if new information comes up. This is similar to having inspections at each phase of construction to ensure everything is correct before proceeding. By using this methodical approach, SDD bridges the gap between your intent and the AI’s actions. The plan serves as a shared reference that keeps both the human and AI on the same page, greatly reducing the chance of misinterpretation. In other words, no more “house instead of hospital” scenarios the AI builds exactly what you envisioned, because you laid out the blueprint together.
So how can a development team put SDD into practice, especially using an AI agent like Rovo Dev? Here are some core guidelines and steps for adopting a spec-driven workflow with your coding AI:
Establish Shared Guidelines: Begin by defining a common set of instructions or standards for the AI. This can include coding conventions, security requirements, performance benchmarks, and any organizational best practices. Having these guidelines written down means you don’t have to repeat them in every prompt, they’re automatically part of the AI’s context.
Break Down the Request: When you give the AI a task, ask it to break large requests into small, verifiable steps instead of solving everything at once. The AI should outline a plan of action with incremental steps. Each step should be roughly the size of a reasonable code change.
Document Each Step: For each step in the plan, ensure there’s a mini-specification. This spec should include a brief summary of the step’s goal, which files or components will be created or modified, key details or requirements for that change, and what the expected outcome is. Essentially, the AI is writing down what it’s about to do before doing it. This documentation can be done in a temporary workspace or draft form, the important part is that it’s written and reviewable.
Always Plan Before Coding: Enforce a rule that the AI should never jump straight into writing code without an approved plan. No matter how small the task, having a short plan first helps catch mistakes. It can be as simple as a few bullet points for a trivial change, or a more detailed design for a complex feature. Planning first means fewer surprises later.
Iterative Execution with Review: Have the AI execute the plan step by step, not all at once. After each step is completed, the AI should summarize what it did and pause for your review. This checkpoint allows you to verify everything went as expected. Only after you review and confirm it should the AI proceed to the next step. This dramatically reduces the risk of compounding errors because you’re inspecting the work continuously.
Clarify Assumptions and Ask Questions: Encourage the AI to actively flag any uncertainties. If the requirements for a step are incomplete or ambiguous, the AI should ask you clarifying questions before proceeding. This might involve the AI explicitly listing assumptions it’s making. By making assumptions visible, you can correct any wrong guesses early on.
Verify Along the Way: For multi-step changes or complex code edits, insert quick verification steps in the plan. For example, after writing code, the AI could run a unit test or a simple build to ensure nothing is broken, and then report the result. These intermediate checks give additional confidence that each piece is working as intended.
Keep the Specs Temporary: Treat the plan documents and intermediate specs as working artifacts, not final deliverables in your product. They serve to guide the development and should be kept out of the production codebase. The idea is to use them to drive quality, not to burden your repository with planning files. Once a step is completed and approved, you can choose to discard that step’s notes or archive them outside the main code repo.
By following these steps with a tool like Rovo Dev, you effectively program the AI on how to collaborate. You transform the AI from a one-shot code generator into a reliable partner that understands your project’s rules and checks in with you regularly.
[Suggested image: "software developer and AI assistant working together on a step-by-step plan on a computer screen"]
To see how this works in practice, consider a real scenario a development team faced. The task was to clean up a set of benchmarking scripts in a codebase, some of which were outdated or no longer in use. Using the Spec-Driven Development approach, the engineer interacted with the Rovo Dev AI agent to tackle this task.
Step 1: Planning the Cleanup
Instead of immediately telling the AI “delete these files” in one go, the engineer prompted Rovo Dev with a request to review all the benchmarking scripts and propose a plan to consolidate them. Because Rovo Dev was operating with SDD principles, it generated a detailed plan rather than performing actions outright. This plan listed each script that might be removed, why it was safe to remove, and a final step to create a new README documentation for the one remaining canonical script. There were about nine steps in total, each documented clearly in the plan output.
Step 2: Reviewing the Plan
The engineer examined the AI’s proposed plan carefully. Doing so revealed an important catch: one of the “stale” scripts the AI planned to delete was actually a work-in-progress that a teammate intended to finish. Because the AI had presented its intentions beforehand, the engineer spotted this incorrect assumption in time. They adjusted the plan, instructing Rovo Dev to keep that particular file. If this had been a normal one-shot prompt scenario, the AI might have simply gone ahead and deleted that file, as it had no way of knowing it was still needed. The SDD approach averted a potential mistake before any code was changed.
Step 3: Executing Step by Step
With the plan corrected and approved, the engineer told Rovo Dev to proceed. The AI went through the steps one by one. For each script that needed removal, it deleted the file and then paused, summarizing: “Removed file X successfully. No references remain.” This gave the human a chance to confirm each deletion was as expected. Step by step, Rovo Dev removed the eight truly stale scripts. Finally, the last step was executed: Rovo Dev created a new README.md file documenting how to use the one remaining benchmark script and explaining that the others were removed. It then presented this new documentation for review.
Step 4: Outcome
At the end of the process, the benchmarking folder was cleaned up perfectly: only the useful script and its config remained, accompanied by a helpful README. No unintended files were lost, and everything was documented. The entire operation was completed in minutes, with minimal risk, because the AI and the human were in sync through the plan. This example highlights the power of SDD with an AI agent. By forcing the AI to lay its cards on the table first, you get to see why it’s choosing each action. The human expert still guides the ship, intervening where the AI’s assumptions don’t match reality. In our example, catching that one mistaken deletion in the plan saved a lot of headache. The AI then became an efficient executor of a well-vetted plan, rather than a rogue coder possibly doing harm. For teams using Rovo Dev or similar AI developer tools, this approach can drastically improve trust and effectiveness. The AI is no longer a black box producing code; it’s more of a junior developer working transparently under the senior developer’s guidance. That means you can harness speed and automation without surrendering control or quality.
Spec-Driven Development offers several clear benefits for software teams, especially when working with AI coding assistants:
Better Alignment with Requirements: Because you spell out the requirements and design in the spec, the AI’s output is far more likely to meet the real needs. The final code does what users or stakeholders actually wanted, reducing the risk of delivering the wrong functionality.
Reduced Rework and Bugs: By catching mistakes in the planning phase, you avoid costly rework later. It’s much easier to tweak a plan or clarify a requirement than to fix a large chunk of misdirected code. SDD leads to fewer bugs and do-overs because potential issues are discovered before code is written.
Maintained Context and Consistency: The spec serves as a persistent context that both you and the AI follow. Even if the task is complex, nothing important falls through the cracks. Every decision is recorded, which also means new team members or stakeholders can understand the project’s direction by looking at the spec and plan.
Incremental Progress with Confidence: Working in small, reviewed steps means you always have a recent, stable state to fall back to. If something goes wrong, you know exactly which step caused it, making troubleshooting easier. There’s no overwhelming dump of code; it’s bite-sized pieces that are easier to test and validate.
Empowered Collaboration with AI: Perhaps the biggest benefit is turning the AI into a true collaborator rather than a code vending machine. You leverage the AI’s speed and knowledge, but within a framework that you control. This synergy can significantly boost productivity: the AI handles the rote work and suggests solutions, while the human provides direction and critical thinking. Over time, the AI also “learns” the project’s standards from the repeated exposure to your guidelines and corrections.
Documentation and Knowledge Sharing: As a side effect, SDD leaves behind useful documentation. The plans and specs created during development can serve as internal documentation or at least as a record of why certain decisions were made. This is great for knowledge sharing and onboarding new developers, because the reasoning is written down, not just in an AI’s hidden context or a developer’s head.
All these advantages contribute to higher quality outcomes. Teams that adopt Spec-Driven Development find that they can move faster without breaking things, because the process inherently balances velocity with thoughtfulness. It’s a way to harness powerful AI tools like Rovo Dev while safeguarding the integrity of your codebase and objectives.
In the rapidly evolving landscape of AI-assisted software development, Spec-Driven Development is more than just a technique it’s a mindset shift. It requires developers to pause and articulate intent before diving into execution. By starting with clear specifications and leveraging automation in a controlled, iterative fashion, teams can achieve far better results than they would with haphazard prompting. SDD ensures that both humans and AI agents are aligned on the goals and the reasoning behind them. The elimination of assumptions and ambiguity means the code that gets written is the code that was actually needed. For organizations experimenting with AI coding agents like Atlassian’s Rovo Dev, adopting SDD can dramatically improve the experience. Instead of treating the AI as an all-knowing wizard, you treat it as a cooperative partner that follows a plan. This not only maintains quality and consistency, but also builds trust in using AI for critical development work. Spec-Driven Development marries the best of human judgment with the efficiency of AI. It brings back the importance of good old planning, but in a way that complements agile workflows and fast-paced cycles. Give SDD a try on your next project, you might be surprised at how much smoother and more productive your AI-augmented development can be.